Copy disabled (too large)
Download .txt
Showing preview only (27,310K chars total). Download the full file to get everything.
Repository: ROBOTIS-GIT/OpenCR
Branch: master
Commit: 68ec75d8a400
Files: 1621
Total size: 25.6 MB
Directory structure:
gitextract_31yzf8ck/
├── .github/
│ └── workflows/
│ └── arduino_ci.yml
├── .gitignore
├── .project
├── 49-stlinkv2.rules
├── 99-opencr-cdc.rules
├── LICENSE
├── README.md
├── arduino/
│ ├── opencr_arduino/
│ │ ├── opencr/
│ │ │ ├── .gitignore
│ │ │ ├── boards.txt
│ │ │ ├── cores/
│ │ │ │ └── arduino/
│ │ │ │ ├── Arduino.h
│ │ │ │ ├── Client.h
│ │ │ │ ├── HardwareSerial.h
│ │ │ │ ├── HardwareTimer.cpp
│ │ │ │ ├── HardwareTimer.h
│ │ │ │ ├── IPAddress.cpp
│ │ │ │ ├── IPAddress.h
│ │ │ │ ├── Print.cpp
│ │ │ │ ├── Print.h
│ │ │ │ ├── Printable.h
│ │ │ │ ├── Reset.h
│ │ │ │ ├── RingBuffer.cpp
│ │ │ │ ├── RingBuffer.h
│ │ │ │ ├── Server.h
│ │ │ │ ├── Stream.cpp
│ │ │ │ ├── Stream.h
│ │ │ │ ├── Tone.cpp
│ │ │ │ ├── Tone.h
│ │ │ │ ├── UARTClass.cpp
│ │ │ │ ├── UARTClass.h
│ │ │ │ ├── USBSerial.cpp
│ │ │ │ ├── USBSerial.h
│ │ │ │ ├── Udp.h
│ │ │ │ ├── WCharacter.h
│ │ │ │ ├── WInterrupts.c
│ │ │ │ ├── WInterrupts.h
│ │ │ │ ├── WMath.cpp
│ │ │ │ ├── WMath.h
│ │ │ │ ├── WString.cpp
│ │ │ │ ├── WString.h
│ │ │ │ ├── avr/
│ │ │ │ │ ├── dtostrf.c
│ │ │ │ │ ├── dtostrf.h
│ │ │ │ │ ├── interrupt.h
│ │ │ │ │ └── pgmspace.h
│ │ │ │ ├── binary.h
│ │ │ │ ├── digitalWriteFast.h
│ │ │ │ ├── itoa.c
│ │ │ │ ├── itoa.h
│ │ │ │ ├── new.cpp
│ │ │ │ ├── syscalls.h
│ │ │ │ ├── wiring.c
│ │ │ │ ├── wiring.h
│ │ │ │ ├── wiring_analog.c
│ │ │ │ ├── wiring_analog.h
│ │ │ │ ├── wiring_constants.h
│ │ │ │ ├── wiring_digital.c
│ │ │ │ ├── wiring_digital.h
│ │ │ │ ├── wiring_private.h
│ │ │ │ ├── wiring_pulse.c
│ │ │ │ ├── wiring_pulse.h
│ │ │ │ ├── wiring_shift.c
│ │ │ │ ├── wiring_shift.h
│ │ │ │ └── yield.cpp
│ │ │ ├── keywords.txt
│ │ │ ├── libraries/
│ │ │ │ ├── Adafruit_GFX_Library/
│ │ │ │ │ ├── Adafruit_GFX.cpp
│ │ │ │ │ ├── Adafruit_GFX.h
│ │ │ │ │ ├── Adafruit_SPITFT.cpp
│ │ │ │ │ ├── Adafruit_SPITFT.h
│ │ │ │ │ ├── Adafruit_SPITFT_Macros.h
│ │ │ │ │ ├── Fonts/
│ │ │ │ │ │ ├── FreeMono12pt7b.h
│ │ │ │ │ │ ├── FreeMono18pt7b.h
│ │ │ │ │ │ ├── FreeMono24pt7b.h
│ │ │ │ │ │ ├── FreeMono9pt7b.h
│ │ │ │ │ │ ├── FreeMonoBold12pt7b.h
│ │ │ │ │ │ ├── FreeMonoBold18pt7b.h
│ │ │ │ │ │ ├── FreeMonoBold24pt7b.h
│ │ │ │ │ │ ├── FreeMonoBold9pt7b.h
│ │ │ │ │ │ ├── FreeMonoBoldOblique12pt7b.h
│ │ │ │ │ │ ├── FreeMonoBoldOblique18pt7b.h
│ │ │ │ │ │ ├── FreeMonoBoldOblique24pt7b.h
│ │ │ │ │ │ ├── FreeMonoBoldOblique9pt7b.h
│ │ │ │ │ │ ├── FreeMonoOblique12pt7b.h
│ │ │ │ │ │ ├── FreeMonoOblique18pt7b.h
│ │ │ │ │ │ ├── FreeMonoOblique24pt7b.h
│ │ │ │ │ │ ├── FreeMonoOblique9pt7b.h
│ │ │ │ │ │ ├── FreeSans12pt7b.h
│ │ │ │ │ │ ├── FreeSans18pt7b.h
│ │ │ │ │ │ ├── FreeSans24pt7b.h
│ │ │ │ │ │ ├── FreeSans9pt7b.h
│ │ │ │ │ │ ├── FreeSansBold12pt7b.h
│ │ │ │ │ │ ├── FreeSansBold18pt7b.h
│ │ │ │ │ │ ├── FreeSansBold24pt7b.h
│ │ │ │ │ │ ├── FreeSansBold9pt7b.h
│ │ │ │ │ │ ├── FreeSansBoldOblique12pt7b.h
│ │ │ │ │ │ ├── FreeSansBoldOblique18pt7b.h
│ │ │ │ │ │ ├── FreeSansBoldOblique24pt7b.h
│ │ │ │ │ │ ├── FreeSansBoldOblique9pt7b.h
│ │ │ │ │ │ ├── FreeSansOblique12pt7b.h
│ │ │ │ │ │ ├── FreeSansOblique18pt7b.h
│ │ │ │ │ │ ├── FreeSansOblique24pt7b.h
│ │ │ │ │ │ ├── FreeSansOblique9pt7b.h
│ │ │ │ │ │ ├── FreeSerif12pt7b.h
│ │ │ │ │ │ ├── FreeSerif18pt7b.h
│ │ │ │ │ │ ├── FreeSerif24pt7b.h
│ │ │ │ │ │ ├── FreeSerif9pt7b.h
│ │ │ │ │ │ ├── FreeSerifBold12pt7b.h
│ │ │ │ │ │ ├── FreeSerifBold18pt7b.h
│ │ │ │ │ │ ├── FreeSerifBold24pt7b.h
│ │ │ │ │ │ ├── FreeSerifBold9pt7b.h
│ │ │ │ │ │ ├── FreeSerifBoldItalic12pt7b.h
│ │ │ │ │ │ ├── FreeSerifBoldItalic18pt7b.h
│ │ │ │ │ │ ├── FreeSerifBoldItalic24pt7b.h
│ │ │ │ │ │ ├── FreeSerifBoldItalic9pt7b.h
│ │ │ │ │ │ ├── FreeSerifItalic12pt7b.h
│ │ │ │ │ │ ├── FreeSerifItalic18pt7b.h
│ │ │ │ │ │ ├── FreeSerifItalic24pt7b.h
│ │ │ │ │ │ ├── FreeSerifItalic9pt7b.h
│ │ │ │ │ │ ├── Org_01.h
│ │ │ │ │ │ ├── Picopixel.h
│ │ │ │ │ │ ├── Tiny3x3a2pt7b
│ │ │ │ │ │ └── TomThumb.h
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── fontconvert/
│ │ │ │ │ │ ├── Makefile
│ │ │ │ │ │ ├── fontconvert.c
│ │ │ │ │ │ ├── fontconvert_win.md
│ │ │ │ │ │ └── makefonts.sh
│ │ │ │ │ ├── gfxfont.h
│ │ │ │ │ ├── glcdfont.c
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── license.txt
│ │ │ │ ├── CAN/
│ │ │ │ │ ├── CAN.cpp
│ │ │ │ │ └── CAN.h
│ │ │ │ ├── DynamixelSDK/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── include/
│ │ │ │ │ │ └── dynamixel_sdk/
│ │ │ │ │ │ ├── dynamixel_sdk.h
│ │ │ │ │ │ ├── group_bulk_read.h
│ │ │ │ │ │ ├── group_bulk_write.h
│ │ │ │ │ │ ├── group_sync_read.h
│ │ │ │ │ │ ├── group_sync_write.h
│ │ │ │ │ │ ├── packet_handler.h
│ │ │ │ │ │ ├── port_handler.h
│ │ │ │ │ │ ├── port_handler_arduino.h
│ │ │ │ │ │ ├── port_handler_linux.h
│ │ │ │ │ │ ├── port_handler_mac.h
│ │ │ │ │ │ ├── port_handler_windows.h
│ │ │ │ │ │ ├── protocol1_packet_handler.h
│ │ │ │ │ │ └── protocol2_packet_handler.h
│ │ │ │ │ ├── keywords.txt
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── DynamixelSDK.h
│ │ │ │ │ └── dynamixel_sdk/
│ │ │ │ │ ├── group_bulk_read.cpp
│ │ │ │ │ ├── group_bulk_write.cpp
│ │ │ │ │ ├── group_sync_read.cpp
│ │ │ │ │ ├── group_sync_write.cpp
│ │ │ │ │ ├── packet_handler.cpp
│ │ │ │ │ ├── port_handler.cpp
│ │ │ │ │ ├── port_handler_arduino.cpp
│ │ │ │ │ ├── port_handler_linux.cpp
│ │ │ │ │ ├── port_handler_mac.cpp
│ │ │ │ │ ├── port_handler_windows.cpp
│ │ │ │ │ ├── protocol1_packet_handler.cpp
│ │ │ │ │ └── protocol2_packet_handler.cpp
│ │ │ │ ├── DynamixelWorkbench/
│ │ │ │ │ ├── include/
│ │ │ │ │ │ └── dynamixel_workbench_toolbox/
│ │ │ │ │ │ ├── dynamixel_driver.h
│ │ │ │ │ │ ├── dynamixel_item.h
│ │ │ │ │ │ ├── dynamixel_tool.h
│ │ │ │ │ │ └── dynamixel_workbench.h
│ │ │ │ │ ├── keywords.txt
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── DynamixelWorkbench.h
│ │ │ │ │ └── dynamixel_workbench_toolbox/
│ │ │ │ │ ├── dynamixel_driver.cpp
│ │ │ │ │ ├── dynamixel_item.cpp
│ │ │ │ │ ├── dynamixel_tool.cpp
│ │ │ │ │ └── dynamixel_workbench.cpp
│ │ │ │ ├── EEPROM/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── keywords.txt
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ └── EEPROM.h
│ │ │ │ ├── Eigen331/
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── Eigen/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── Cholesky
│ │ │ │ │ │ ├── CholmodSupport
│ │ │ │ │ │ ├── Core
│ │ │ │ │ │ ├── Dense
│ │ │ │ │ │ ├── Eigen
│ │ │ │ │ │ ├── Eigenvalues
│ │ │ │ │ │ ├── Geometry
│ │ │ │ │ │ ├── Householder
│ │ │ │ │ │ ├── IterativeLinearSolvers
│ │ │ │ │ │ ├── Jacobi
│ │ │ │ │ │ ├── LU
│ │ │ │ │ │ ├── MetisSupport
│ │ │ │ │ │ ├── OrderingMethods
│ │ │ │ │ │ ├── PaStiXSupport
│ │ │ │ │ │ ├── PardisoSupport
│ │ │ │ │ │ ├── QR
│ │ │ │ │ │ ├── QtAlignedMalloc
│ │ │ │ │ │ ├── SPQRSupport
│ │ │ │ │ │ ├── SVD
│ │ │ │ │ │ ├── Sparse
│ │ │ │ │ │ ├── SparseCholesky
│ │ │ │ │ │ ├── SparseCore
│ │ │ │ │ │ ├── SparseLU
│ │ │ │ │ │ ├── SparseQR
│ │ │ │ │ │ ├── StdDeque
│ │ │ │ │ │ ├── StdList
│ │ │ │ │ │ ├── StdVector
│ │ │ │ │ │ ├── SuperLUSupport
│ │ │ │ │ │ ├── UmfPackSupport
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── Cholesky/
│ │ │ │ │ │ │ ├── LDLT.h
│ │ │ │ │ │ │ ├── LLT.h
│ │ │ │ │ │ │ └── LLT_LAPACKE.h
│ │ │ │ │ │ ├── CholmodSupport/
│ │ │ │ │ │ │ └── CholmodSupport.h
│ │ │ │ │ │ ├── Core/
│ │ │ │ │ │ │ ├── Array.h
│ │ │ │ │ │ │ ├── ArrayBase.h
│ │ │ │ │ │ │ ├── ArrayWrapper.h
│ │ │ │ │ │ │ ├── Assign.h
│ │ │ │ │ │ │ ├── AssignEvaluator.h
│ │ │ │ │ │ │ ├── Assign_MKL.h
│ │ │ │ │ │ │ ├── BandMatrix.h
│ │ │ │ │ │ │ ├── Block.h
│ │ │ │ │ │ │ ├── BooleanRedux.h
│ │ │ │ │ │ │ ├── CommaInitializer.h
│ │ │ │ │ │ │ ├── ConditionEstimator.h
│ │ │ │ │ │ │ ├── CoreEvaluators.h
│ │ │ │ │ │ │ ├── CoreIterators.h
│ │ │ │ │ │ │ ├── CwiseBinaryOp.h
│ │ │ │ │ │ │ ├── CwiseNullaryOp.h
│ │ │ │ │ │ │ ├── CwiseTernaryOp.h
│ │ │ │ │ │ │ ├── CwiseUnaryOp.h
│ │ │ │ │ │ │ ├── CwiseUnaryView.h
│ │ │ │ │ │ │ ├── DenseBase.h
│ │ │ │ │ │ │ ├── DenseCoeffsBase.h
│ │ │ │ │ │ │ ├── DenseStorage.h
│ │ │ │ │ │ │ ├── Diagonal.h
│ │ │ │ │ │ │ ├── DiagonalMatrix.h
│ │ │ │ │ │ │ ├── DiagonalProduct.h
│ │ │ │ │ │ │ ├── Dot.h
│ │ │ │ │ │ │ ├── EigenBase.h
│ │ │ │ │ │ │ ├── ForceAlignedAccess.h
│ │ │ │ │ │ │ ├── Fuzzy.h
│ │ │ │ │ │ │ ├── GeneralProduct.h
│ │ │ │ │ │ │ ├── GenericPacketMath.h
│ │ │ │ │ │ │ ├── GlobalFunctions.h
│ │ │ │ │ │ │ ├── IO.h
│ │ │ │ │ │ │ ├── Inverse.h
│ │ │ │ │ │ │ ├── Map.h
│ │ │ │ │ │ │ ├── MapBase.h
│ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ ├── MathFunctionsImpl.h
│ │ │ │ │ │ │ ├── Matrix.h
│ │ │ │ │ │ │ ├── MatrixBase.h
│ │ │ │ │ │ │ ├── NestByValue.h
│ │ │ │ │ │ │ ├── NoAlias.h
│ │ │ │ │ │ │ ├── NumTraits.h
│ │ │ │ │ │ │ ├── PermutationMatrix.h
│ │ │ │ │ │ │ ├── PlainObjectBase.h
│ │ │ │ │ │ │ ├── Product.h
│ │ │ │ │ │ │ ├── ProductEvaluators.h
│ │ │ │ │ │ │ ├── Random.h
│ │ │ │ │ │ │ ├── Redux.h
│ │ │ │ │ │ │ ├── Ref.h
│ │ │ │ │ │ │ ├── Replicate.h
│ │ │ │ │ │ │ ├── ReturnByValue.h
│ │ │ │ │ │ │ ├── Reverse.h
│ │ │ │ │ │ │ ├── Select.h
│ │ │ │ │ │ │ ├── SelfAdjointView.h
│ │ │ │ │ │ │ ├── SelfCwiseBinaryOp.h
│ │ │ │ │ │ │ ├── Solve.h
│ │ │ │ │ │ │ ├── SolveTriangular.h
│ │ │ │ │ │ │ ├── SolverBase.h
│ │ │ │ │ │ │ ├── StableNorm.h
│ │ │ │ │ │ │ ├── Stride.h
│ │ │ │ │ │ │ ├── Swap.h
│ │ │ │ │ │ │ ├── Transpose.h
│ │ │ │ │ │ │ ├── Transpositions.h
│ │ │ │ │ │ │ ├── TriangularMatrix.h
│ │ │ │ │ │ │ ├── VectorBlock.h
│ │ │ │ │ │ │ ├── VectorwiseOp.h
│ │ │ │ │ │ │ ├── Visitor.h
│ │ │ │ │ │ │ ├── arch/
│ │ │ │ │ │ │ │ ├── AVX/
│ │ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ │ │ │ ├── AVX512/
│ │ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ │ │ │ ├── AltiVec/
│ │ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ │ │ │ ├── CUDA/
│ │ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ │ ├── Half.h
│ │ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ │ │ │ ├── PacketMathHalf.h
│ │ │ │ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ │ │ │ ├── Default/
│ │ │ │ │ │ │ │ │ └── Settings.h
│ │ │ │ │ │ │ │ ├── NEON/
│ │ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ │ │ │ ├── SSE/
│ │ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ │ │ │ └── ZVector/
│ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ │ │ ├── functors/
│ │ │ │ │ │ │ │ ├── AssignmentFunctors.h
│ │ │ │ │ │ │ │ ├── BinaryFunctors.h
│ │ │ │ │ │ │ │ ├── NullaryFunctors.h
│ │ │ │ │ │ │ │ ├── StlFunctors.h
│ │ │ │ │ │ │ │ ├── TernaryFunctors.h
│ │ │ │ │ │ │ │ └── UnaryFunctors.h
│ │ │ │ │ │ │ ├── products/
│ │ │ │ │ │ │ │ ├── GeneralBlockPanelKernel.h
│ │ │ │ │ │ │ │ ├── GeneralMatrixMatrix.h
│ │ │ │ │ │ │ │ ├── GeneralMatrixMatrixTriangular.h
│ │ │ │ │ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h
│ │ │ │ │ │ │ │ ├── GeneralMatrixMatrix_BLAS.h
│ │ │ │ │ │ │ │ ├── GeneralMatrixVector.h
│ │ │ │ │ │ │ │ ├── GeneralMatrixVector_BLAS.h
│ │ │ │ │ │ │ │ ├── Parallelizer.h
│ │ │ │ │ │ │ │ ├── SelfadjointMatrixMatrix.h
│ │ │ │ │ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h
│ │ │ │ │ │ │ │ ├── SelfadjointMatrixVector.h
│ │ │ │ │ │ │ │ ├── SelfadjointMatrixVector_BLAS.h
│ │ │ │ │ │ │ │ ├── SelfadjointProduct.h
│ │ │ │ │ │ │ │ ├── SelfadjointRank2Update.h
│ │ │ │ │ │ │ │ ├── TriangularMatrixMatrix.h
│ │ │ │ │ │ │ │ ├── TriangularMatrixMatrix_BLAS.h
│ │ │ │ │ │ │ │ ├── TriangularMatrixVector.h
│ │ │ │ │ │ │ │ ├── TriangularMatrixVector_BLAS.h
│ │ │ │ │ │ │ │ ├── TriangularSolverMatrix.h
│ │ │ │ │ │ │ │ ├── TriangularSolverMatrix_BLAS.h
│ │ │ │ │ │ │ │ └── TriangularSolverVector.h
│ │ │ │ │ │ │ └── util/
│ │ │ │ │ │ │ ├── BlasUtil.h
│ │ │ │ │ │ │ ├── Constants.h
│ │ │ │ │ │ │ ├── DisableStupidWarnings.h
│ │ │ │ │ │ │ ├── ForwardDeclarations.h
│ │ │ │ │ │ │ ├── MKL_support.h
│ │ │ │ │ │ │ ├── Macros.h
│ │ │ │ │ │ │ ├── Memory.h
│ │ │ │ │ │ │ ├── Meta.h
│ │ │ │ │ │ │ ├── NonMPL2.h
│ │ │ │ │ │ │ ├── ReenableStupidWarnings.h
│ │ │ │ │ │ │ ├── StaticAssert.h
│ │ │ │ │ │ │ └── XprHelper.h
│ │ │ │ │ │ ├── Eigenvalues/
│ │ │ │ │ │ │ ├── ComplexEigenSolver.h
│ │ │ │ │ │ │ ├── ComplexSchur.h
│ │ │ │ │ │ │ ├── ComplexSchur_LAPACKE.h
│ │ │ │ │ │ │ ├── EigenSolver.h
│ │ │ │ │ │ │ ├── GeneralizedEigenSolver.h
│ │ │ │ │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h
│ │ │ │ │ │ │ ├── HessenbergDecomposition.h
│ │ │ │ │ │ │ ├── MatrixBaseEigenvalues.h
│ │ │ │ │ │ │ ├── RealQZ.h
│ │ │ │ │ │ │ ├── RealSchur.h
│ │ │ │ │ │ │ ├── RealSchur_LAPACKE.h
│ │ │ │ │ │ │ ├── SelfAdjointEigenSolver.h
│ │ │ │ │ │ │ ├── SelfAdjointEigenSolver_LAPACKE.h
│ │ │ │ │ │ │ └── Tridiagonalization.h
│ │ │ │ │ │ ├── Geometry/
│ │ │ │ │ │ │ ├── AlignedBox.h
│ │ │ │ │ │ │ ├── AngleAxis.h
│ │ │ │ │ │ │ ├── EulerAngles.h
│ │ │ │ │ │ │ ├── Homogeneous.h
│ │ │ │ │ │ │ ├── Hyperplane.h
│ │ │ │ │ │ │ ├── OrthoMethods.h
│ │ │ │ │ │ │ ├── ParametrizedLine.h
│ │ │ │ │ │ │ ├── Quaternion.h
│ │ │ │ │ │ │ ├── Rotation2D.h
│ │ │ │ │ │ │ ├── RotationBase.h
│ │ │ │ │ │ │ ├── Scaling.h
│ │ │ │ │ │ │ ├── Transform.h
│ │ │ │ │ │ │ ├── Translation.h
│ │ │ │ │ │ │ ├── Umeyama.h
│ │ │ │ │ │ │ └── arch/
│ │ │ │ │ │ │ └── Geometry_SSE.h
│ │ │ │ │ │ ├── Householder/
│ │ │ │ │ │ │ ├── BlockHouseholder.h
│ │ │ │ │ │ │ ├── Householder.h
│ │ │ │ │ │ │ └── HouseholderSequence.h
│ │ │ │ │ │ ├── IterativeLinearSolvers/
│ │ │ │ │ │ │ ├── BasicPreconditioners.h
│ │ │ │ │ │ │ ├── BiCGSTAB.h
│ │ │ │ │ │ │ ├── ConjugateGradient.h
│ │ │ │ │ │ │ ├── IncompleteCholesky.h
│ │ │ │ │ │ │ ├── IncompleteLUT.h
│ │ │ │ │ │ │ ├── IterativeSolverBase.h
│ │ │ │ │ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ │ │ │ │ └── SolveWithGuess.h
│ │ │ │ │ │ ├── Jacobi/
│ │ │ │ │ │ │ └── Jacobi.h
│ │ │ │ │ │ ├── LU/
│ │ │ │ │ │ │ ├── Determinant.h
│ │ │ │ │ │ │ ├── FullPivLU.h
│ │ │ │ │ │ │ ├── InverseImpl.h
│ │ │ │ │ │ │ ├── PartialPivLU.h
│ │ │ │ │ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ │ │ │ │ └── arch/
│ │ │ │ │ │ │ └── Inverse_SSE.h
│ │ │ │ │ │ ├── MetisSupport/
│ │ │ │ │ │ │ └── MetisSupport.h
│ │ │ │ │ │ ├── OrderingMethods/
│ │ │ │ │ │ │ ├── Amd.h
│ │ │ │ │ │ │ ├── Eigen_Colamd.h
│ │ │ │ │ │ │ └── Ordering.h
│ │ │ │ │ │ ├── PaStiXSupport/
│ │ │ │ │ │ │ └── PaStiXSupport.h
│ │ │ │ │ │ ├── PardisoSupport/
│ │ │ │ │ │ │ └── PardisoSupport.h
│ │ │ │ │ │ ├── QR/
│ │ │ │ │ │ │ ├── ColPivHouseholderQR.h
│ │ │ │ │ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ │ │ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ │ │ │ │ ├── FullPivHouseholderQR.h
│ │ │ │ │ │ │ ├── HouseholderQR.h
│ │ │ │ │ │ │ └── HouseholderQR_LAPACKE.h
│ │ │ │ │ │ ├── SPQRSupport/
│ │ │ │ │ │ │ └── SuiteSparseQRSupport.h
│ │ │ │ │ │ ├── SVD/
│ │ │ │ │ │ │ ├── BDCSVD.h
│ │ │ │ │ │ │ ├── JacobiSVD.h
│ │ │ │ │ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ │ │ │ │ ├── SVDBase.h
│ │ │ │ │ │ │ └── UpperBidiagonalization.h
│ │ │ │ │ │ ├── SparseCholesky/
│ │ │ │ │ │ │ ├── SimplicialCholesky.h
│ │ │ │ │ │ │ └── SimplicialCholesky_impl.h
│ │ │ │ │ │ ├── SparseCore/
│ │ │ │ │ │ │ ├── AmbiVector.h
│ │ │ │ │ │ │ ├── CompressedStorage.h
│ │ │ │ │ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ │ │ │ │ ├── MappedSparseMatrix.h
│ │ │ │ │ │ │ ├── SparseAssign.h
│ │ │ │ │ │ │ ├── SparseBlock.h
│ │ │ │ │ │ │ ├── SparseColEtree.h
│ │ │ │ │ │ │ ├── SparseCompressedBase.h
│ │ │ │ │ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ │ │ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ │ │ │ │ ├── SparseDenseProduct.h
│ │ │ │ │ │ │ ├── SparseDiagonalProduct.h
│ │ │ │ │ │ │ ├── SparseDot.h
│ │ │ │ │ │ │ ├── SparseFuzzy.h
│ │ │ │ │ │ │ ├── SparseMap.h
│ │ │ │ │ │ │ ├── SparseMatrix.h
│ │ │ │ │ │ │ ├── SparseMatrixBase.h
│ │ │ │ │ │ │ ├── SparsePermutation.h
│ │ │ │ │ │ │ ├── SparseProduct.h
│ │ │ │ │ │ │ ├── SparseRedux.h
│ │ │ │ │ │ │ ├── SparseRef.h
│ │ │ │ │ │ │ ├── SparseSelfAdjointView.h
│ │ │ │ │ │ │ ├── SparseSolverBase.h
│ │ │ │ │ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ │ │ │ │ ├── SparseTranspose.h
│ │ │ │ │ │ │ ├── SparseTriangularView.h
│ │ │ │ │ │ │ ├── SparseUtil.h
│ │ │ │ │ │ │ ├── SparseVector.h
│ │ │ │ │ │ │ ├── SparseView.h
│ │ │ │ │ │ │ └── TriangularSolver.h
│ │ │ │ │ │ ├── SparseLU/
│ │ │ │ │ │ │ ├── SparseLU.h
│ │ │ │ │ │ │ ├── SparseLUImpl.h
│ │ │ │ │ │ │ ├── SparseLU_Memory.h
│ │ │ │ │ │ │ ├── SparseLU_Structs.h
│ │ │ │ │ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ │ │ │ │ ├── SparseLU_Utils.h
│ │ │ │ │ │ │ ├── SparseLU_column_bmod.h
│ │ │ │ │ │ │ ├── SparseLU_column_dfs.h
│ │ │ │ │ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ │ │ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ │ │ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ │ │ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ │ │ │ │ ├── SparseLU_panel_bmod.h
│ │ │ │ │ │ │ ├── SparseLU_panel_dfs.h
│ │ │ │ │ │ │ ├── SparseLU_pivotL.h
│ │ │ │ │ │ │ ├── SparseLU_pruneL.h
│ │ │ │ │ │ │ └── SparseLU_relax_snode.h
│ │ │ │ │ │ ├── SparseQR/
│ │ │ │ │ │ │ └── SparseQR.h
│ │ │ │ │ │ ├── StlSupport/
│ │ │ │ │ │ │ ├── StdDeque.h
│ │ │ │ │ │ │ ├── StdList.h
│ │ │ │ │ │ │ ├── StdVector.h
│ │ │ │ │ │ │ └── details.h
│ │ │ │ │ │ ├── SuperLUSupport/
│ │ │ │ │ │ │ └── SuperLUSupport.h
│ │ │ │ │ │ ├── UmfPackSupport/
│ │ │ │ │ │ │ └── UmfPackSupport.h
│ │ │ │ │ │ ├── misc/
│ │ │ │ │ │ │ ├── Image.h
│ │ │ │ │ │ │ ├── Kernel.h
│ │ │ │ │ │ │ ├── RealSvd2x2.h
│ │ │ │ │ │ │ ├── blas.h
│ │ │ │ │ │ │ ├── lapack.h
│ │ │ │ │ │ │ ├── lapacke.h
│ │ │ │ │ │ │ └── lapacke_mangling.h
│ │ │ │ │ │ └── plugins/
│ │ │ │ │ │ ├── ArrayCwiseBinaryOps.h
│ │ │ │ │ │ ├── ArrayCwiseUnaryOps.h
│ │ │ │ │ │ ├── BlockMethods.h
│ │ │ │ │ │ ├── CommonCwiseBinaryOps.h
│ │ │ │ │ │ ├── CommonCwiseUnaryOps.h
│ │ │ │ │ │ ├── MatrixCwiseBinaryOps.h
│ │ │ │ │ │ └── MatrixCwiseUnaryOps.h
│ │ │ │ │ └── Eigen.h
│ │ │ │ ├── HX8347D/
│ │ │ │ │ ├── LCD.cpp
│ │ │ │ │ ├── LCD.h
│ │ │ │ │ ├── font.c
│ │ │ │ │ └── font.h
│ │ │ │ ├── I2Cdev/
│ │ │ │ │ ├── I2Cdev.cpp
│ │ │ │ │ ├── I2Cdev.h
│ │ │ │ │ ├── keywords.txt
│ │ │ │ │ └── library.json
│ │ │ │ ├── IMU/
│ │ │ │ │ ├── Define.h
│ │ │ │ │ ├── ICM20648.cpp
│ │ │ │ │ ├── ICM20648.h
│ │ │ │ │ ├── ICM20648_REGS.h
│ │ │ │ │ ├── IMU.cpp
│ │ │ │ │ ├── IMU.h
│ │ │ │ │ ├── MPU9250.cpp
│ │ │ │ │ ├── MPU9250.h
│ │ │ │ │ ├── MPU9250_REGS.h
│ │ │ │ │ ├── MadgwickAHRS.cpp
│ │ │ │ │ ├── MadgwickAHRS.h
│ │ │ │ │ ├── imu_selector.cpp
│ │ │ │ │ ├── imu_selector.h
│ │ │ │ │ ├── imu_spi.cpp
│ │ │ │ │ ├── imu_spi.h
│ │ │ │ │ └── keywords.txt
│ │ │ │ ├── LcdTouchPanel/
│ │ │ │ │ ├── LcdTouchPanel.cpp
│ │ │ │ │ ├── LcdTouchPanel.h
│ │ │ │ │ └── library.properties
│ │ │ │ ├── OLLO/
│ │ │ │ │ ├── OLLO.cpp
│ │ │ │ │ ├── OLLO.h
│ │ │ │ │ └── keywords.txt
│ │ │ │ ├── OP3/
│ │ │ │ │ ├── OP3.cpp
│ │ │ │ │ ├── OP3.h
│ │ │ │ │ └── examples/
│ │ │ │ │ └── opencr_op3/
│ │ │ │ │ ├── dxl.cpp
│ │ │ │ │ ├── dxl.h
│ │ │ │ │ ├── dxl_debug.cpp
│ │ │ │ │ ├── dxl_debug.h
│ │ │ │ │ ├── dxl_def.h
│ │ │ │ │ ├── dxl_hw.cpp
│ │ │ │ │ ├── dxl_hw.h
│ │ │ │ │ ├── dxl_hw_op3.cpp
│ │ │ │ │ ├── dxl_hw_op3.h
│ │ │ │ │ ├── dxl_node_op3.cpp
│ │ │ │ │ ├── dxl_node_op3.h
│ │ │ │ │ └── opencr_op3.ino
│ │ │ │ ├── OpenCR/
│ │ │ │ │ ├── OpenCR.cpp
│ │ │ │ │ ├── OpenCR.h
│ │ │ │ │ └── examples/
│ │ │ │ │ ├── 01. Basics/
│ │ │ │ │ │ ├── a_Bare_Minimum/
│ │ │ │ │ │ │ └── a_Bare_Minimum.ino
│ │ │ │ │ │ ├── b_Blink_LED/
│ │ │ │ │ │ │ └── b_Blink_LED.ino
│ │ │ │ │ │ ├── c_Digital_Read_Serial/
│ │ │ │ │ │ │ └── c_Digital_Read_Serial.ino
│ │ │ │ │ │ ├── d_Analog_Read_Serial/
│ │ │ │ │ │ │ └── d_Analog_Read_Serial.ino
│ │ │ │ │ │ ├── e_Read_Analog_Voltage/
│ │ │ │ │ │ │ └── e_Read_Analog_Voltage.ino
│ │ │ │ │ │ └── f_Gpio_Write_Speed_Test/
│ │ │ │ │ │ └── f_Gpio_Write_Speed_Test.ino
│ │ │ │ │ ├── 02. Digital/
│ │ │ │ │ │ ├── a_toneMelody/
│ │ │ │ │ │ │ ├── a_toneMelody.ino
│ │ │ │ │ │ │ └── pitches.h
│ │ │ │ │ │ └── b_PWM/
│ │ │ │ │ │ └── b_PWM.ino
│ │ │ │ │ ├── 03. Communication/
│ │ │ │ │ │ └── a_Serial_HelloWorld/
│ │ │ │ │ │ └── a_Serial_HelloWorld.ino
│ │ │ │ │ ├── 04. Interrupt/
│ │ │ │ │ │ ├── a_EXIT_Interrupt_Serial/
│ │ │ │ │ │ │ └── a_EXIT_Interrupt_Serial.ino
│ │ │ │ │ │ └── d_Timer_Interrupt_LED/
│ │ │ │ │ │ └── d_Timer_Interrupt_LED.ino
│ │ │ │ │ ├── 05. Sensors/
│ │ │ │ │ │ ├── OLLO_COLOR_Read/
│ │ │ │ │ │ │ └── OLLO_COLOR_Read.ino
│ │ │ │ │ │ ├── OLLO_DMS_Read/
│ │ │ │ │ │ │ └── OLLO_DMS_Read.ino
│ │ │ │ │ │ ├── OLLO_IR_Read/
│ │ │ │ │ │ │ └── OLLO_IR_Read.ino
│ │ │ │ │ │ ├── OLLO_TOUCH_Read/
│ │ │ │ │ │ │ └── OLLO_TOUCH_Read.ino
│ │ │ │ │ │ └── OLLO_TPS_READ/
│ │ │ │ │ │ └── OLLO_TPS_READ.ino
│ │ │ │ │ ├── 06. RC100/
│ │ │ │ │ │ └── RC100/
│ │ │ │ │ │ └── RC100.ino
│ │ │ │ │ ├── 07. DynamixelSDK/
│ │ │ │ │ │ ├── dxl_monitor/
│ │ │ │ │ │ │ └── dxl_monitor.ino
│ │ │ │ │ │ ├── protocol1.0/
│ │ │ │ │ │ │ ├── bulk_read/
│ │ │ │ │ │ │ │ └── bulk_read.ino
│ │ │ │ │ │ │ ├── ping/
│ │ │ │ │ │ │ │ └── ping.ino
│ │ │ │ │ │ │ ├── read_write/
│ │ │ │ │ │ │ │ └── read_write.ino
│ │ │ │ │ │ │ ├── reset/
│ │ │ │ │ │ │ │ └── reset.ino
│ │ │ │ │ │ │ └── sync_write/
│ │ │ │ │ │ │ └── sync_write.ino
│ │ │ │ │ │ ├── protocol2.0/
│ │ │ │ │ │ │ ├── broadcast_ping/
│ │ │ │ │ │ │ │ └── broadcast_ping.ino
│ │ │ │ │ │ │ ├── bulk_read_write/
│ │ │ │ │ │ │ │ └── bulk_read_write.ino
│ │ │ │ │ │ │ ├── factory_reset/
│ │ │ │ │ │ │ │ └── factory_reset.ino
│ │ │ │ │ │ │ ├── indirect_address/
│ │ │ │ │ │ │ │ └── indirect_address.ino
│ │ │ │ │ │ │ ├── ping/
│ │ │ │ │ │ │ │ └── ping.ino
│ │ │ │ │ │ │ ├── read_write/
│ │ │ │ │ │ │ │ └── read_write.ino
│ │ │ │ │ │ │ ├── reboot/
│ │ │ │ │ │ │ │ └── reboot.ino
│ │ │ │ │ │ │ └── sync_read_write/
│ │ │ │ │ │ │ └── sync_read_write.ino
│ │ │ │ │ │ └── protocol_combined/
│ │ │ │ │ │ └── protocol_combined.ino
│ │ │ │ │ ├── 08. DynamixelWorkbench/
│ │ │ │ │ │ ├── a_Model_Scan/
│ │ │ │ │ │ │ └── a_Model_Scan.ino
│ │ │ │ │ │ ├── b_Ping/
│ │ │ │ │ │ │ └── b_Ping.ino
│ │ │ │ │ │ ├── c_ID_Change/
│ │ │ │ │ │ │ └── c_ID_Change.ino
│ │ │ │ │ │ ├── d_BPS_Change/
│ │ │ │ │ │ │ └── d_BPS_Change.ino
│ │ │ │ │ │ ├── e_Mode_Change/
│ │ │ │ │ │ │ └── e_Mode_Change.ino
│ │ │ │ │ │ ├── f_Reboot/
│ │ │ │ │ │ │ └── f_Reboot.ino
│ │ │ │ │ │ ├── g_Reset/
│ │ │ │ │ │ │ └── g_Reset.ino
│ │ │ │ │ │ ├── h_Position/
│ │ │ │ │ │ │ └── h_Position.ino
│ │ │ │ │ │ ├── i_Velocity/
│ │ │ │ │ │ │ └── i_Velocity.ino
│ │ │ │ │ │ ├── j_Current_Based_Position/
│ │ │ │ │ │ │ └── j_Current_Based_Position.ino
│ │ │ │ │ │ ├── k_Read_Write/
│ │ │ │ │ │ │ └── k_Read_Write.ino
│ │ │ │ │ │ ├── l_Sync_Write/
│ │ │ │ │ │ │ └── l_Sync_Write.ino
│ │ │ │ │ │ ├── m_Sync_Read_Write/
│ │ │ │ │ │ │ └── m_Sync_Read_Write.ino
│ │ │ │ │ │ ├── n_Bulk_Read_Write/
│ │ │ │ │ │ │ └── n_Bulk_Read_Write.ino
│ │ │ │ │ │ ├── o_Find_Dynamixel/
│ │ │ │ │ │ │ └── o_Find_Dynamixel.ino
│ │ │ │ │ │ └── p_Monitor/
│ │ │ │ │ │ └── p_Monitor.ino
│ │ │ │ │ ├── 09. IMU/
│ │ │ │ │ │ ├── IMU_Read_AccRAW/
│ │ │ │ │ │ │ └── IMU_Read_AccRAW.ino
│ │ │ │ │ │ ├── IMU_Read_GyroRAW/
│ │ │ │ │ │ │ └── IMU_Read_GyroRAW.ino
│ │ │ │ │ │ └── IMU_Read_RollPitchYaw/
│ │ │ │ │ │ └── IMU_Read_RollPitchYaw.ino
│ │ │ │ │ └── 10. Etc/
│ │ │ │ │ ├── CAMERA/
│ │ │ │ │ │ └── ov7725_al422b/
│ │ │ │ │ │ ├── ov7725_al422b.cpp
│ │ │ │ │ │ ├── ov7725_al422b.h
│ │ │ │ │ │ ├── ov7725_al422b.ino
│ │ │ │ │ │ ├── settings.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── OV7725/
│ │ │ │ │ │ │ ├── OV7725.cpp
│ │ │ │ │ │ │ └── OV7725.h
│ │ │ │ │ │ ├── sccb/
│ │ │ │ │ │ │ ├── sccb.c
│ │ │ │ │ │ │ └── sccb.h
│ │ │ │ │ │ ├── tftLcd.cpp
│ │ │ │ │ │ └── tftLcd.h
│ │ │ │ │ ├── CAN/
│ │ │ │ │ │ ├── canMaskFilter/
│ │ │ │ │ │ │ └── canMaskFilter.ino
│ │ │ │ │ │ ├── canRxInterrupt/
│ │ │ │ │ │ │ └── canRxInterrupt.ino
│ │ │ │ │ │ ├── canTxRxByte/
│ │ │ │ │ │ │ └── canTxRxByte.ino
│ │ │ │ │ │ └── canTxRxMessage/
│ │ │ │ │ │ └── canTxRxMessage.ino
│ │ │ │ │ ├── EEPROM/
│ │ │ │ │ │ ├── eeprom_clear/
│ │ │ │ │ │ │ └── eeprom_clear.ino
│ │ │ │ │ │ ├── eeprom_crc/
│ │ │ │ │ │ │ └── eeprom_crc.ino
│ │ │ │ │ │ ├── eeprom_get/
│ │ │ │ │ │ │ └── eeprom_get.ino
│ │ │ │ │ │ ├── eeprom_iteration/
│ │ │ │ │ │ │ └── eeprom_iteration.ino
│ │ │ │ │ │ ├── eeprom_put/
│ │ │ │ │ │ │ └── eeprom_put.ino
│ │ │ │ │ │ ├── eeprom_read/
│ │ │ │ │ │ │ └── eeprom_read.ino
│ │ │ │ │ │ ├── eeprom_update/
│ │ │ │ │ │ │ └── eeprom_update.ino
│ │ │ │ │ │ └── eeprom_write/
│ │ │ │ │ │ └── eeprom_write.ino
│ │ │ │ │ ├── Eigen/
│ │ │ │ │ │ └── eigen_test/
│ │ │ │ │ │ └── eigen_test.ino
│ │ │ │ │ ├── FreeRTOS/
│ │ │ │ │ │ └── thread_led/
│ │ │ │ │ │ └── thread_led.ino
│ │ │ │ │ ├── LDS/
│ │ │ │ │ │ └── drawLDS/
│ │ │ │ │ │ ├── drawLDS.ino
│ │ │ │ │ │ ├── lds.cpp
│ │ │ │ │ │ └── lds.h
│ │ │ │ │ ├── SPI/
│ │ │ │ │ │ └── using_SPI_ports/
│ │ │ │ │ │ └── using_SPI_ports.ino
│ │ │ │ │ ├── Servo/
│ │ │ │ │ │ ├── Knob/
│ │ │ │ │ │ │ └── Knob.ino
│ │ │ │ │ │ └── Sweep/
│ │ │ │ │ │ └── Sweep.ino
│ │ │ │ │ ├── TFT/
│ │ │ │ │ │ ├── tft_shape/
│ │ │ │ │ │ │ └── tft_shape/
│ │ │ │ │ │ │ └── tft_shape.ino
│ │ │ │ │ │ ├── tft_text/
│ │ │ │ │ │ │ └── tft_text/
│ │ │ │ │ │ │ └── tft_text.ino
│ │ │ │ │ │ └── tft_touch/
│ │ │ │ │ │ └── tft_touch/
│ │ │ │ │ │ └── tft_touch.ino
│ │ │ │ │ ├── Waveshare/
│ │ │ │ │ │ ├── breakouttouchpaint/
│ │ │ │ │ │ │ └── breakouttouchpaint.ino
│ │ │ │ │ │ ├── graphicstest/
│ │ │ │ │ │ │ └── graphicstest.ino
│ │ │ │ │ │ ├── lcd_logo/
│ │ │ │ │ │ │ ├── lcd_logo.ino
│ │ │ │ │ │ │ ├── logo.cpp
│ │ │ │ │ │ │ └── logo.h
│ │ │ │ │ │ ├── spitftbitmap/
│ │ │ │ │ │ │ └── spitftbitmap.ino
│ │ │ │ │ │ └── tft_box/
│ │ │ │ │ │ └── tft_box.ino
│ │ │ │ │ ├── rtc_time/
│ │ │ │ │ │ └── rtc_time.ino
│ │ │ │ │ └── usb_to_dxl/
│ │ │ │ │ └── usb_to_dxl.ino
│ │ │ │ ├── OpenManipulator/
│ │ │ │ │ ├── example/
│ │ │ │ │ │ ├── Chain/
│ │ │ │ │ │ │ ├── open_manipulator_chain/
│ │ │ │ │ │ │ │ ├── demo.h
│ │ │ │ │ │ │ │ ├── open_manipulator_chain.ino
│ │ │ │ │ │ │ │ ├── processing.h
│ │ │ │ │ │ │ │ └── remote_controller.h
│ │ │ │ │ │ │ ├── open_manipulator_chain_ROS/
│ │ │ │ │ │ │ │ ├── open_manipulator_chain_ROS.h
│ │ │ │ │ │ │ │ └── open_manipulator_chain_ROS.ino
│ │ │ │ │ │ │ ├── open_manipulator_chain_pen/
│ │ │ │ │ │ │ │ ├── open_manipulator_chain_pen.ino
│ │ │ │ │ │ │ │ ├── open_manipulator_pen.h
│ │ │ │ │ │ │ │ ├── open_manipulator_pen_drawing.cpp
│ │ │ │ │ │ │ │ ├── open_manipulator_pen_drawing.h
│ │ │ │ │ │ │ │ ├── open_manipulator_pen_motion.h
│ │ │ │ │ │ │ │ └── processing.h
│ │ │ │ │ │ │ ├── open_manipulator_chain_teaching/
│ │ │ │ │ │ │ │ └── open_manipulator_chain_teaching.ino
│ │ │ │ │ │ │ └── open_manipulator_chain_vacuum/
│ │ │ │ │ │ │ ├── actuator.h
│ │ │ │ │ │ │ ├── open_manipulator_chain_vacuum.ino
│ │ │ │ │ │ │ ├── open_manipulator_vacuum.h
│ │ │ │ │ │ │ ├── open_manipulator_vacuum_motion.h
│ │ │ │ │ │ │ └── processing.h
│ │ │ │ │ │ ├── Delta/
│ │ │ │ │ │ │ └── open_manipulator_delta/
│ │ │ │ │ │ │ ├── demo.h
│ │ │ │ │ │ │ ├── open_manipulator_delta.ino
│ │ │ │ │ │ │ ├── processing.h
│ │ │ │ │ │ │ └── remotecontroller100.h
│ │ │ │ │ │ ├── Linear/
│ │ │ │ │ │ │ └── open_manipulator_linear/
│ │ │ │ │ │ │ ├── demo.h
│ │ │ │ │ │ │ ├── open_manipulator_linear.ino
│ │ │ │ │ │ │ ├── processing.h
│ │ │ │ │ │ │ └── remotecontroller100.h
│ │ │ │ │ │ ├── Link/
│ │ │ │ │ │ │ └── open_manipulator_link/
│ │ │ │ │ │ │ ├── link.h
│ │ │ │ │ │ │ ├── link_kinematics.h
│ │ │ │ │ │ │ ├── motion.h
│ │ │ │ │ │ │ ├── open_manipulator_link.ino
│ │ │ │ │ │ │ ├── processing.h
│ │ │ │ │ │ │ ├── remote_controller.h
│ │ │ │ │ │ │ └── vacuum_actuator.h
│ │ │ │ │ │ ├── Planar/
│ │ │ │ │ │ │ └── open_manipulator_planar/
│ │ │ │ │ │ │ ├── demo.h
│ │ │ │ │ │ │ ├── open_manipulator_planar.ino
│ │ │ │ │ │ │ ├── processing.h
│ │ │ │ │ │ │ └── remotecontroller100.h
│ │ │ │ │ │ ├── Scara/
│ │ │ │ │ │ │ └── open_manipulator_scara/
│ │ │ │ │ │ │ ├── demo.h
│ │ │ │ │ │ │ ├── open_manipulator_scara.ino
│ │ │ │ │ │ │ ├── processing.h
│ │ │ │ │ │ │ └── remotecontroller100.h
│ │ │ │ │ │ └── Stewart/
│ │ │ │ │ │ └── open_manipulator_stewart/
│ │ │ │ │ │ ├── demo.h
│ │ │ │ │ │ ├── demo2.h
│ │ │ │ │ │ ├── open_manipulator_stewart.ino
│ │ │ │ │ │ ├── processing.h
│ │ │ │ │ │ └── remotecontroller100.h
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── delta_libs/
│ │ │ │ │ │ ├── include/
│ │ │ │ │ │ │ └── delta_libs/
│ │ │ │ │ │ │ ├── delta.h
│ │ │ │ │ │ │ ├── delta_custom_trajectory.h
│ │ │ │ │ │ │ ├── delta_dynamixel.h
│ │ │ │ │ │ │ └── delta_kinematics.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── delta.cpp
│ │ │ │ │ │ ├── delta_custom_trajectory.cpp
│ │ │ │ │ │ ├── delta_dynamixel.cpp
│ │ │ │ │ │ └── delta_kinematics.cpp
│ │ │ │ │ ├── delta_libs.h
│ │ │ │ │ ├── linear_libs/
│ │ │ │ │ │ ├── include/
│ │ │ │ │ │ │ └── linear_libs/
│ │ │ │ │ │ │ ├── linear.h
│ │ │ │ │ │ │ ├── linear_custom_trajectory.h
│ │ │ │ │ │ │ ├── linear_dynamixel.h
│ │ │ │ │ │ │ └── linear_kinematics.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── linear.cpp
│ │ │ │ │ │ ├── linear_custom_trajectory.cpp
│ │ │ │ │ │ ├── linear_dynamixel.cpp
│ │ │ │ │ │ └── linear_kinematics.cpp
│ │ │ │ │ ├── linear_libs.h
│ │ │ │ │ ├── open_manipulator_libs/
│ │ │ │ │ │ ├── include/
│ │ │ │ │ │ │ └── open_manipulator_libs/
│ │ │ │ │ │ │ ├── custom_trajectory.h
│ │ │ │ │ │ │ ├── dynamixel.h
│ │ │ │ │ │ │ ├── kinematics.h
│ │ │ │ │ │ │ └── open_manipulator.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── custom_trajectory.cpp
│ │ │ │ │ │ ├── dynamixel.cpp
│ │ │ │ │ │ ├── kinematics.cpp
│ │ │ │ │ │ └── open_manipulator.cpp
│ │ │ │ │ ├── open_manipulator_libs.h
│ │ │ │ │ ├── open_manipulator_msgs/
│ │ │ │ │ │ ├── GetJointPosition.h
│ │ │ │ │ │ ├── GetKinematicsPose.h
│ │ │ │ │ │ ├── JointPosition.h
│ │ │ │ │ │ ├── KinematicsPose.h
│ │ │ │ │ │ ├── OpenManipulatorState.h
│ │ │ │ │ │ ├── SetActuatorState.h
│ │ │ │ │ │ ├── SetDrawingTrajectory.h
│ │ │ │ │ │ ├── SetJointPosition.h
│ │ │ │ │ │ └── SetKinematicsPose.h
│ │ │ │ │ ├── planar_libs/
│ │ │ │ │ │ ├── include/
│ │ │ │ │ │ │ └── planar_libs/
│ │ │ │ │ │ │ ├── planar.h
│ │ │ │ │ │ │ ├── planar_custom_trajectory.h
│ │ │ │ │ │ │ ├── planar_dynamixel.h
│ │ │ │ │ │ │ └── planar_kinematics.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── planar.cpp
│ │ │ │ │ │ ├── planar_custom_trajectory.cpp
│ │ │ │ │ │ ├── planar_dynamixel.cpp
│ │ │ │ │ │ └── planar_kinematics.cpp
│ │ │ │ │ ├── planar_libs.h
│ │ │ │ │ ├── scara_libs/
│ │ │ │ │ │ ├── include/
│ │ │ │ │ │ │ └── scara_libs/
│ │ │ │ │ │ │ ├── scara.h
│ │ │ │ │ │ │ ├── scara_custom_trajectory.h
│ │ │ │ │ │ │ ├── scara_dynamixel.h
│ │ │ │ │ │ │ └── scara_kinematics.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── scara.cpp
│ │ │ │ │ │ ├── scara_custom_trajectory.cpp
│ │ │ │ │ │ ├── scara_dynamixel.cpp
│ │ │ │ │ │ └── scara_kinematics.cpp
│ │ │ │ │ ├── scara_libs.h
│ │ │ │ │ ├── stewart_libs/
│ │ │ │ │ │ ├── include/
│ │ │ │ │ │ │ └── stewart_libs/
│ │ │ │ │ │ │ ├── stewart.h
│ │ │ │ │ │ │ ├── stewart_custom_trajectory.h
│ │ │ │ │ │ │ ├── stewart_dynamixel.h
│ │ │ │ │ │ │ └── stewart_kinematics.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── stewart.cpp
│ │ │ │ │ │ ├── stewart_custom_trajectory.cpp
│ │ │ │ │ │ ├── stewart_dynamixel.cpp
│ │ │ │ │ │ └── stewart_kinematics.cpp
│ │ │ │ │ └── stewart_libs.h
│ │ │ │ ├── RC100/
│ │ │ │ │ ├── RC100.cpp
│ │ │ │ │ └── RC100.h
│ │ │ │ ├── ROS/
│ │ │ │ │ ├── OpenCR_ROS.cpp
│ │ │ │ │ ├── OpenCR_ROS.h
│ │ │ │ │ └── examples/
│ │ │ │ │ ├── 01. Basics/
│ │ │ │ │ │ ├── a_LED/
│ │ │ │ │ │ │ └── a_LED.ino
│ │ │ │ │ │ ├── b_Button/
│ │ │ │ │ │ │ └── b_Button.ino
│ │ │ │ │ │ ├── c_Voltage/
│ │ │ │ │ │ │ └── c_Voltage.ino
│ │ │ │ │ │ └── d_IMU/
│ │ │ │ │ │ └── d_IMU.ino
│ │ │ │ │ └── 02. Sensors/
│ │ │ │ │ ├── a_bumper/
│ │ │ │ │ │ └── a_bumper.ino
│ │ │ │ │ ├── b_cliff/
│ │ │ │ │ │ └── b_cliff.ino
│ │ │ │ │ ├── c_Ultrasonic/
│ │ │ │ │ │ └── c_Ultrasonic.ino
│ │ │ │ │ └── d_Illumination/
│ │ │ │ │ └── d_Illumination.ino
│ │ │ │ ├── RTOS/
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── FreeRTOS.h
│ │ │ │ │ ├── FreeRTOSConfig.h
│ │ │ │ │ ├── RTOS.cpp
│ │ │ │ │ ├── RTOS.h
│ │ │ │ │ ├── StackMacros.h
│ │ │ │ │ ├── cmsis_os.c
│ │ │ │ │ ├── cmsis_os.h
│ │ │ │ │ ├── croutine.c
│ │ │ │ │ ├── croutine.h
│ │ │ │ │ ├── deprecated_definitions.h
│ │ │ │ │ ├── event_groups.c
│ │ │ │ │ ├── event_groups.h
│ │ │ │ │ ├── heap_3.c
│ │ │ │ │ ├── list.c
│ │ │ │ │ ├── list.h
│ │ │ │ │ ├── mpu_wrappers.h
│ │ │ │ │ ├── port.c
│ │ │ │ │ ├── portable.h
│ │ │ │ │ ├── portmacro.h
│ │ │ │ │ ├── projdefs.h
│ │ │ │ │ ├── queue.c
│ │ │ │ │ ├── queue.h
│ │ │ │ │ ├── readme.txt
│ │ │ │ │ ├── semphr.h
│ │ │ │ │ ├── st_readme.txt
│ │ │ │ │ ├── stdint.readme
│ │ │ │ │ ├── task.h
│ │ │ │ │ ├── tasks.c
│ │ │ │ │ ├── timers.c
│ │ │ │ │ └── timers.h
│ │ │ │ ├── RobotisManipulator/
│ │ │ │ │ ├── include/
│ │ │ │ │ │ └── robotis_manipulator/
│ │ │ │ │ │ ├── robotis_manipulator.h
│ │ │ │ │ │ ├── robotis_manipulator_common.h
│ │ │ │ │ │ ├── robotis_manipulator_log.h
│ │ │ │ │ │ ├── robotis_manipulator_manager.h
│ │ │ │ │ │ ├── robotis_manipulator_math.h
│ │ │ │ │ │ └── robotis_manipulator_trajectory_generator.h
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── RobotisManipulator.h
│ │ │ │ │ └── robotis_manipulator/
│ │ │ │ │ ├── robotis_manipulator.cpp
│ │ │ │ │ ├── robotis_manipulator_common.cpp
│ │ │ │ │ ├── robotis_manipulator_log.cpp
│ │ │ │ │ ├── robotis_manipulator_manager.cpp
│ │ │ │ │ ├── robotis_manipulator_math.cpp
│ │ │ │ │ └── robotis_manipulator_trajectory_generator.cpp
│ │ │ │ ├── SPI/
│ │ │ │ │ ├── EventResponder.cpp
│ │ │ │ │ ├── EventResponder.h
│ │ │ │ │ ├── SPI.cpp
│ │ │ │ │ ├── SPI.h
│ │ │ │ │ └── keywords.txt
│ │ │ │ ├── Servo/
│ │ │ │ │ ├── README.adoc
│ │ │ │ │ ├── keywords.txt
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── Servo.cpp
│ │ │ │ │ └── Servo.h
│ │ │ │ ├── Touch/
│ │ │ │ │ ├── Touch.cpp
│ │ │ │ │ └── Touch.h
│ │ │ │ ├── Waveshare_HX8347D/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── Waveshare_HX8347D.cpp
│ │ │ │ │ ├── Waveshare_HX8347D.h
│ │ │ │ │ └── library.properties
│ │ │ │ ├── Wire/
│ │ │ │ │ ├── README
│ │ │ │ │ ├── SlowSoftI2CMaster.cpp
│ │ │ │ │ ├── SlowSoftI2CMaster.h
│ │ │ │ │ ├── Wire.cpp
│ │ │ │ │ ├── Wire.h
│ │ │ │ │ └── keywords.txt
│ │ │ │ ├── XPT2046/
│ │ │ │ │ ├── XPT2046.cpp
│ │ │ │ │ └── XPT2046.h
│ │ │ │ ├── turtlebot3/
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ ├── turtlebot3_burger/
│ │ │ │ │ │ │ └── turtlebot3_core/
│ │ │ │ │ │ │ ├── turtlebot3_burger.h
│ │ │ │ │ │ │ ├── turtlebot3_core.ino
│ │ │ │ │ │ │ └── turtlebot3_core_config.h
│ │ │ │ │ │ ├── turtlebot3_friends/
│ │ │ │ │ │ │ ├── turtlebot3_bike/
│ │ │ │ │ │ │ │ ├── turtlebot3_bike.h
│ │ │ │ │ │ │ │ ├── turtlebot3_bike.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_bike_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_bike_motor_driver.h
│ │ │ │ │ │ │ ├── turtlebot3_car/
│ │ │ │ │ │ │ │ ├── turtlebot3_car.h
│ │ │ │ │ │ │ │ ├── turtlebot3_car.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_car_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_car_motor_driver.h
│ │ │ │ │ │ │ ├── turtlebot3_conveyor/
│ │ │ │ │ │ │ │ ├── turtlebot3_conveyor.h
│ │ │ │ │ │ │ │ ├── turtlebot3_conveyor.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_conveyor_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_conveyor_motor_driver.h
│ │ │ │ │ │ │ ├── turtlebot3_mecanum/
│ │ │ │ │ │ │ │ ├── turtlebot3_mecanum.h
│ │ │ │ │ │ │ │ ├── turtlebot3_mecanum.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_mecanum_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_mecanum_motor_driver.h
│ │ │ │ │ │ │ ├── turtlebot3_monster/
│ │ │ │ │ │ │ │ ├── turtlebot3_monster.h
│ │ │ │ │ │ │ │ ├── turtlebot3_monster.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_monster_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_monster_motor_driver.h
│ │ │ │ │ │ │ ├── turtlebot3_omni/
│ │ │ │ │ │ │ │ ├── turtlebot3_omni.h
│ │ │ │ │ │ │ │ ├── turtlebot3_omni.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_omni_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_omni_motor_driver.h
│ │ │ │ │ │ │ ├── turtlebot3_realturtlebot/
│ │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot.h
│ │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot_motion.h
│ │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_realturtlebot_motor_driver.h
│ │ │ │ │ │ │ ├── turtlebot3_road_train/
│ │ │ │ │ │ │ │ ├── turtlebot3_road_train.h
│ │ │ │ │ │ │ │ ├── turtlebot3_road_train.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_road_train_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_road_train_motor_driver.h
│ │ │ │ │ │ │ ├── turtlebot3_segway/
│ │ │ │ │ │ │ │ ├── turtlebot3_segway.h
│ │ │ │ │ │ │ │ ├── turtlebot3_segway.ino
│ │ │ │ │ │ │ │ ├── turtlebot3_segway_motor_driver.cpp
│ │ │ │ │ │ │ │ └── turtlebot3_segway_motor_driver.h
│ │ │ │ │ │ │ └── turtlebot3_tank/
│ │ │ │ │ │ │ ├── turtlebot3_tank.h
│ │ │ │ │ │ │ ├── turtlebot3_tank.ino
│ │ │ │ │ │ │ ├── turtlebot3_tank_motor_driver.cpp
│ │ │ │ │ │ │ └── turtlebot3_tank_motor_driver.h
│ │ │ │ │ │ ├── turtlebot3_setup/
│ │ │ │ │ │ │ └── turtlebot3_setup_motor/
│ │ │ │ │ │ │ └── turtlebot3_setup_motor.ino
│ │ │ │ │ │ ├── turtlebot3_waffle/
│ │ │ │ │ │ │ └── turtlebot3_core/
│ │ │ │ │ │ │ ├── turtlebot3_core.ino
│ │ │ │ │ │ │ ├── turtlebot3_core_config.h
│ │ │ │ │ │ │ └── turtlebot3_waffle.h
│ │ │ │ │ │ └── turtlebot3_with_open_manipulator/
│ │ │ │ │ │ └── turtlebot3_with_open_manipulator_core/
│ │ │ │ │ │ ├── open_manipulator_driver.cpp
│ │ │ │ │ │ ├── open_manipulator_driver.h
│ │ │ │ │ │ ├── turtlebot3_with_open_manipulator.h
│ │ │ │ │ │ ├── turtlebot3_with_open_manipulator_core.ino
│ │ │ │ │ │ └── turtlebot3_with_open_manipulator_core_config.h
│ │ │ │ │ ├── include/
│ │ │ │ │ │ └── turtlebot3/
│ │ │ │ │ │ ├── turtlebot3.h
│ │ │ │ │ │ ├── turtlebot3_controller.h
│ │ │ │ │ │ ├── turtlebot3_diagnosis.h
│ │ │ │ │ │ ├── turtlebot3_motor_driver.h
│ │ │ │ │ │ └── turtlebot3_sensor.h
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── TurtleBot3.h
│ │ │ │ │ └── turtlebot3/
│ │ │ │ │ ├── turtlebot3_controller.cpp
│ │ │ │ │ ├── turtlebot3_diagnosis.cpp
│ │ │ │ │ ├── turtlebot3_motor_driver.cpp
│ │ │ │ │ └── turtlebot3_sensor.cpp
│ │ │ │ ├── turtlebot3_ros2/
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ ├── turtlebot3_burger/
│ │ │ │ │ │ │ └── turtlebot3_burger.ino
│ │ │ │ │ │ ├── turtlebot3_manipulation/
│ │ │ │ │ │ │ └── turtlebot3_manipulation.ino
│ │ │ │ │ │ └── turtlebot3_waffle/
│ │ │ │ │ │ └── turtlebot3_waffle.ino
│ │ │ │ │ ├── include/
│ │ │ │ │ │ └── turtlebot3/
│ │ │ │ │ │ ├── open_manipulator_driver.h
│ │ │ │ │ │ ├── turtlebot3.h
│ │ │ │ │ │ ├── turtlebot3_controller.h
│ │ │ │ │ │ ├── turtlebot3_diagnosis.h
│ │ │ │ │ │ ├── turtlebot3_motor_driver.h
│ │ │ │ │ │ └── turtlebot3_sensor.h
│ │ │ │ │ ├── library.properties
│ │ │ │ │ └── src/
│ │ │ │ │ ├── TurtleBot3_ROS2.h
│ │ │ │ │ └── turtlebot3/
│ │ │ │ │ ├── open_manipulator_driver.cpp
│ │ │ │ │ ├── turtlebot3.cpp
│ │ │ │ │ ├── turtlebot3_controller.cpp
│ │ │ │ │ ├── turtlebot3_diagnosis.cpp
│ │ │ │ │ ├── turtlebot3_motor_driver.cpp
│ │ │ │ │ └── turtlebot3_sensor.cpp
│ │ │ │ └── turtlebot3_ros_lib/
│ │ │ │ ├── ArduinoHardware.h
│ │ │ │ ├── duration.cpp
│ │ │ │ ├── geometry_msgs/
│ │ │ │ │ ├── Accel.h
│ │ │ │ │ ├── AccelStamped.h
│ │ │ │ │ ├── AccelWithCovariance.h
│ │ │ │ │ ├── AccelWithCovarianceStamped.h
│ │ │ │ │ ├── Inertia.h
│ │ │ │ │ ├── InertiaStamped.h
│ │ │ │ │ ├── Point.h
│ │ │ │ │ ├── Point32.h
│ │ │ │ │ ├── PointStamped.h
│ │ │ │ │ ├── Polygon.h
│ │ │ │ │ ├── PolygonStamped.h
│ │ │ │ │ ├── Pose.h
│ │ │ │ │ ├── Pose2D.h
│ │ │ │ │ ├── PoseArray.h
│ │ │ │ │ ├── PoseStamped.h
│ │ │ │ │ ├── PoseWithCovariance.h
│ │ │ │ │ ├── PoseWithCovarianceStamped.h
│ │ │ │ │ ├── Quaternion.h
│ │ │ │ │ ├── QuaternionStamped.h
│ │ │ │ │ ├── Transform.h
│ │ │ │ │ ├── TransformStamped.h
│ │ │ │ │ ├── Twist.h
│ │ │ │ │ ├── TwistStamped.h
│ │ │ │ │ ├── TwistWithCovariance.h
│ │ │ │ │ ├── TwistWithCovarianceStamped.h
│ │ │ │ │ ├── Vector3.h
│ │ │ │ │ ├── Vector3Stamped.h
│ │ │ │ │ ├── Wrench.h
│ │ │ │ │ └── WrenchStamped.h
│ │ │ │ ├── nav_msgs/
│ │ │ │ │ ├── GetMap.h
│ │ │ │ │ ├── GetMapAction.h
│ │ │ │ │ ├── GetMapActionFeedback.h
│ │ │ │ │ ├── GetMapActionGoal.h
│ │ │ │ │ ├── GetMapActionResult.h
│ │ │ │ │ ├── GetMapFeedback.h
│ │ │ │ │ ├── GetMapGoal.h
│ │ │ │ │ ├── GetMapResult.h
│ │ │ │ │ ├── GetPlan.h
│ │ │ │ │ ├── GridCells.h
│ │ │ │ │ ├── MapMetaData.h
│ │ │ │ │ ├── OccupancyGrid.h
│ │ │ │ │ ├── Odometry.h
│ │ │ │ │ ├── Path.h
│ │ │ │ │ └── SetMap.h
│ │ │ │ ├── ros/
│ │ │ │ │ ├── duration.h
│ │ │ │ │ ├── msg.h
│ │ │ │ │ ├── node_handle.h
│ │ │ │ │ ├── publisher.h
│ │ │ │ │ ├── service_client.h
│ │ │ │ │ ├── service_server.h
│ │ │ │ │ ├── subscriber.h
│ │ │ │ │ └── time.h
│ │ │ │ ├── ros.h
│ │ │ │ ├── roscpp/
│ │ │ │ │ ├── Empty.h
│ │ │ │ │ ├── GetLoggers.h
│ │ │ │ │ ├── Logger.h
│ │ │ │ │ └── SetLoggerLevel.h
│ │ │ │ ├── rosserial_arduino/
│ │ │ │ │ ├── Adc.h
│ │ │ │ │ └── Test.h
│ │ │ │ ├── rosserial_msgs/
│ │ │ │ │ ├── Log.h
│ │ │ │ │ ├── RequestMessageInfo.h
│ │ │ │ │ ├── RequestParam.h
│ │ │ │ │ ├── RequestServiceInfo.h
│ │ │ │ │ └── TopicInfo.h
│ │ │ │ ├── sensor_msgs/
│ │ │ │ │ ├── BatteryState.h
│ │ │ │ │ ├── BatteryStateNoetic.h
│ │ │ │ │ ├── CameraInfo.h
│ │ │ │ │ ├── ChannelFloat32.h
│ │ │ │ │ ├── CompressedImage.h
│ │ │ │ │ ├── FluidPressure.h
│ │ │ │ │ ├── Illuminance.h
│ │ │ │ │ ├── Image.h
│ │ │ │ │ ├── Imu.h
│ │ │ │ │ ├── JointState.h
│ │ │ │ │ ├── Joy.h
│ │ │ │ │ ├── JoyFeedback.h
│ │ │ │ │ ├── JoyFeedbackArray.h
│ │ │ │ │ ├── LaserEcho.h
│ │ │ │ │ ├── LaserScan.h
│ │ │ │ │ ├── MagneticField.h
│ │ │ │ │ ├── MultiDOFJointState.h
│ │ │ │ │ ├── MultiEchoLaserScan.h
│ │ │ │ │ ├── NavSatFix.h
│ │ │ │ │ ├── NavSatStatus.h
│ │ │ │ │ ├── PointCloud.h
│ │ │ │ │ ├── PointCloud2.h
│ │ │ │ │ ├── PointField.h
│ │ │ │ │ ├── Range.h
│ │ │ │ │ ├── RegionOfInterest.h
│ │ │ │ │ ├── RelativeHumidity.h
│ │ │ │ │ ├── SetCameraInfo.h
│ │ │ │ │ ├── Temperature.h
│ │ │ │ │ └── TimeReference.h
│ │ │ │ ├── std_msgs/
│ │ │ │ │ ├── Bool.h
│ │ │ │ │ ├── Byte.h
│ │ │ │ │ ├── ByteMultiArray.h
│ │ │ │ │ ├── Char.h
│ │ │ │ │ ├── ColorRGBA.h
│ │ │ │ │ ├── Duration.h
│ │ │ │ │ ├── Empty.h
│ │ │ │ │ ├── Float32.h
│ │ │ │ │ ├── Float32MultiArray.h
│ │ │ │ │ ├── Float64.h
│ │ │ │ │ ├── Float64MultiArray.h
│ │ │ │ │ ├── Header.h
│ │ │ │ │ ├── Int16.h
│ │ │ │ │ ├── Int16MultiArray.h
│ │ │ │ │ ├── Int32.h
│ │ │ │ │ ├── Int32MultiArray.h
│ │ │ │ │ ├── Int64.h
│ │ │ │ │ ├── Int64MultiArray.h
│ │ │ │ │ ├── Int8.h
│ │ │ │ │ ├── Int8MultiArray.h
│ │ │ │ │ ├── MultiArrayDimension.h
│ │ │ │ │ ├── MultiArrayLayout.h
│ │ │ │ │ ├── String.h
│ │ │ │ │ ├── Time.h
│ │ │ │ │ ├── UInt16.h
│ │ │ │ │ ├── UInt16MultiArray.h
│ │ │ │ │ ├── UInt32.h
│ │ │ │ │ ├── UInt32MultiArray.h
│ │ │ │ │ ├── UInt64.h
│ │ │ │ │ ├── UInt64MultiArray.h
│ │ │ │ │ ├── UInt8.h
│ │ │ │ │ └── UInt8MultiArray.h
│ │ │ │ ├── std_srvs/
│ │ │ │ │ ├── Empty.h
│ │ │ │ │ ├── SetBool.h
│ │ │ │ │ └── Trigger.h
│ │ │ │ ├── tf/
│ │ │ │ │ ├── FrameGraph.h
│ │ │ │ │ ├── tf.h
│ │ │ │ │ ├── tfMessage.h
│ │ │ │ │ └── transform_broadcaster.h
│ │ │ │ ├── tf2_msgs/
│ │ │ │ │ ├── FrameGraph.h
│ │ │ │ │ ├── LookupTransformAction.h
│ │ │ │ │ ├── LookupTransformActionFeedback.h
│ │ │ │ │ ├── LookupTransformActionGoal.h
│ │ │ │ │ ├── LookupTransformActionResult.h
│ │ │ │ │ ├── LookupTransformFeedback.h
│ │ │ │ │ ├── LookupTransformGoal.h
│ │ │ │ │ ├── LookupTransformResult.h
│ │ │ │ │ ├── TF2Error.h
│ │ │ │ │ └── TFMessage.h
│ │ │ │ ├── time.cpp
│ │ │ │ ├── trajectory_msgs/
│ │ │ │ │ ├── JointTrajectory.h
│ │ │ │ │ ├── JointTrajectoryPoint.h
│ │ │ │ │ ├── MultiDOFJointTrajectory.h
│ │ │ │ │ └── MultiDOFJointTrajectoryPoint.h
│ │ │ │ └── turtlebot3_msgs/
│ │ │ │ ├── SensorState.h
│ │ │ │ ├── Sound.h
│ │ │ │ └── VersionInfo.h
│ │ │ ├── platform.txt
│ │ │ ├── programmers.txt
│ │ │ └── variants/
│ │ │ └── OpenCR/
│ │ │ ├── bsp/
│ │ │ │ └── opencr/
│ │ │ │ ├── bsp.c
│ │ │ │ ├── bsp.h
│ │ │ │ ├── include/
│ │ │ │ │ ├── arm_common_tables.h
│ │ │ │ │ ├── arm_const_structs.h
│ │ │ │ │ ├── arm_math.h
│ │ │ │ │ ├── cmsis_armcc.h
│ │ │ │ │ ├── cmsis_armcc_V6.h
│ │ │ │ │ ├── cmsis_gcc.h
│ │ │ │ │ ├── core_cm0.h
│ │ │ │ │ ├── core_cm0plus.h
│ │ │ │ │ ├── core_cm3.h
│ │ │ │ │ ├── core_cm4.h
│ │ │ │ │ ├── core_cm7.h
│ │ │ │ │ ├── core_cmFunc.h
│ │ │ │ │ ├── core_cmInstr.h
│ │ │ │ │ ├── core_cmSimd.h
│ │ │ │ │ ├── core_sc000.h
│ │ │ │ │ └── core_sc300.h
│ │ │ │ ├── ldscript/
│ │ │ │ │ └── opencr_flash.ld
│ │ │ │ ├── startup/
│ │ │ │ │ └── startup_stm32f746xx.S
│ │ │ │ ├── stm32f746xx.h
│ │ │ │ ├── stm32f7xx.h
│ │ │ │ ├── stm32f7xx_hal_conf.h
│ │ │ │ ├── stm32f7xx_it.c
│ │ │ │ ├── stm32f7xx_it.h
│ │ │ │ ├── syscalls.c
│ │ │ │ ├── system_clock.c
│ │ │ │ ├── system_clock.h
│ │ │ │ ├── system_stm32f7xx.c
│ │ │ │ └── system_stm32f7xx.h
│ │ │ ├── chip.h
│ │ │ ├── hw/
│ │ │ │ ├── def.h
│ │ │ │ ├── def_err.h
│ │ │ │ ├── driver/
│ │ │ │ │ ├── delay.c
│ │ │ │ │ ├── delay.h
│ │ │ │ │ ├── dma_stream_handlers.c
│ │ │ │ │ ├── dma_stream_handlers.h
│ │ │ │ │ ├── drv_adc.c
│ │ │ │ │ ├── drv_adc.h
│ │ │ │ │ ├── drv_can.c
│ │ │ │ │ ├── drv_can.h
│ │ │ │ │ ├── drv_dxl.c
│ │ │ │ │ ├── drv_dxl.h
│ │ │ │ │ ├── drv_eeprom.c
│ │ │ │ │ ├── drv_eeprom.h
│ │ │ │ │ ├── drv_exti.c
│ │ │ │ │ ├── drv_exti.h
│ │ │ │ │ ├── drv_i2c.c
│ │ │ │ │ ├── drv_i2c.h
│ │ │ │ │ ├── drv_micros.c
│ │ │ │ │ ├── drv_micros.h
│ │ │ │ │ ├── drv_pwm.c
│ │ │ │ │ ├── drv_pwm.h
│ │ │ │ │ ├── drv_rtc.c
│ │ │ │ │ ├── drv_rtc.h
│ │ │ │ │ ├── drv_spi.c
│ │ │ │ │ ├── drv_spi.h
│ │ │ │ │ ├── drv_timer.c
│ │ │ │ │ ├── drv_timer.h
│ │ │ │ │ ├── drv_uart.c
│ │ │ │ │ ├── drv_uart.h
│ │ │ │ │ ├── flash.c
│ │ │ │ │ ├── flash.h
│ │ │ │ │ ├── ring.c
│ │ │ │ │ ├── ring.h
│ │ │ │ │ ├── vcp.c
│ │ │ │ │ ├── vcp.h
│ │ │ │ │ ├── wdg.c
│ │ │ │ │ └── wdg.h
│ │ │ │ ├── hw.c
│ │ │ │ ├── hw.h
│ │ │ │ └── usb_cdc/
│ │ │ │ ├── usbd_cdc.c
│ │ │ │ ├── usbd_cdc.h
│ │ │ │ ├── usbd_cdc_interface.c
│ │ │ │ ├── usbd_cdc_interface.h
│ │ │ │ ├── usbd_conf.c
│ │ │ │ ├── usbd_conf.h
│ │ │ │ ├── usbd_core.c
│ │ │ │ ├── usbd_core.h
│ │ │ │ ├── usbd_ctlreq.c
│ │ │ │ ├── usbd_ctlreq.h
│ │ │ │ ├── usbd_def.h
│ │ │ │ ├── usbd_desc.c
│ │ │ │ ├── usbd_desc.h
│ │ │ │ ├── usbd_ioreq.c
│ │ │ │ └── usbd_ioreq.h
│ │ │ ├── lib/
│ │ │ │ └── STM32F7xx_HAL_Driver/
│ │ │ │ ├── Inc/
│ │ │ │ │ ├── Legacy/
│ │ │ │ │ │ └── stm32_hal_legacy.h
│ │ │ │ │ ├── stm32f7xx_hal.h
│ │ │ │ │ ├── stm32f7xx_hal_adc.h
│ │ │ │ │ ├── stm32f7xx_hal_adc_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_can.h
│ │ │ │ │ ├── stm32f7xx_hal_cec.h
│ │ │ │ │ ├── stm32f7xx_hal_cortex.h
│ │ │ │ │ ├── stm32f7xx_hal_crc.h
│ │ │ │ │ ├── stm32f7xx_hal_crc_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_cryp.h
│ │ │ │ │ ├── stm32f7xx_hal_cryp_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_dac.h
│ │ │ │ │ ├── stm32f7xx_hal_dac_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_dcmi.h
│ │ │ │ │ ├── stm32f7xx_hal_dcmi_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_def.h
│ │ │ │ │ ├── stm32f7xx_hal_dma.h
│ │ │ │ │ ├── stm32f7xx_hal_dma2d.h
│ │ │ │ │ ├── stm32f7xx_hal_dma_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_eth.h
│ │ │ │ │ ├── stm32f7xx_hal_flash.h
│ │ │ │ │ ├── stm32f7xx_hal_flash_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_gpio.h
│ │ │ │ │ ├── stm32f7xx_hal_gpio_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_hash.h
│ │ │ │ │ ├── stm32f7xx_hal_hash_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_hcd.h
│ │ │ │ │ ├── stm32f7xx_hal_i2c.h
│ │ │ │ │ ├── stm32f7xx_hal_i2c_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_i2s.h
│ │ │ │ │ ├── stm32f7xx_hal_irda.h
│ │ │ │ │ ├── stm32f7xx_hal_irda_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_iwdg.h
│ │ │ │ │ ├── stm32f7xx_hal_lptim.h
│ │ │ │ │ ├── stm32f7xx_hal_ltdc.h
│ │ │ │ │ ├── stm32f7xx_hal_nand.h
│ │ │ │ │ ├── stm32f7xx_hal_nor.h
│ │ │ │ │ ├── stm32f7xx_hal_pcd.h
│ │ │ │ │ ├── stm32f7xx_hal_pcd_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_pwr.h
│ │ │ │ │ ├── stm32f7xx_hal_pwr_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_qspi.h
│ │ │ │ │ ├── stm32f7xx_hal_rcc.h
│ │ │ │ │ ├── stm32f7xx_hal_rcc_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_rng.h
│ │ │ │ │ ├── stm32f7xx_hal_rtc.h
│ │ │ │ │ ├── stm32f7xx_hal_rtc_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_sai.h
│ │ │ │ │ ├── stm32f7xx_hal_sai_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_sd.h
│ │ │ │ │ ├── stm32f7xx_hal_sdram.h
│ │ │ │ │ ├── stm32f7xx_hal_smartcard.h
│ │ │ │ │ ├── stm32f7xx_hal_smartcard_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_spdifrx.h
│ │ │ │ │ ├── stm32f7xx_hal_spi.h
│ │ │ │ │ ├── stm32f7xx_hal_sram.h
│ │ │ │ │ ├── stm32f7xx_hal_tim.h
│ │ │ │ │ ├── stm32f7xx_hal_tim_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_uart.h
│ │ │ │ │ ├── stm32f7xx_hal_uart_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_usart.h
│ │ │ │ │ ├── stm32f7xx_hal_usart_ex.h
│ │ │ │ │ ├── stm32f7xx_hal_wwdg.h
│ │ │ │ │ ├── stm32f7xx_ll_fmc.h
│ │ │ │ │ ├── stm32f7xx_ll_sdmmc.h
│ │ │ │ │ └── stm32f7xx_ll_usb.h
│ │ │ │ ├── Release_Notes.html
│ │ │ │ └── Src/
│ │ │ │ ├── stm32f7xx_hal.c
│ │ │ │ ├── stm32f7xx_hal_adc.c
│ │ │ │ ├── stm32f7xx_hal_adc_ex.c
│ │ │ │ ├── stm32f7xx_hal_can.c
│ │ │ │ ├── stm32f7xx_hal_cec.c
│ │ │ │ ├── stm32f7xx_hal_cortex.c
│ │ │ │ ├── stm32f7xx_hal_crc.c
│ │ │ │ ├── stm32f7xx_hal_crc_ex.c
│ │ │ │ ├── stm32f7xx_hal_cryp.c
│ │ │ │ ├── stm32f7xx_hal_cryp_ex.c
│ │ │ │ ├── stm32f7xx_hal_dma.c
│ │ │ │ ├── stm32f7xx_hal_dma2d.c
│ │ │ │ ├── stm32f7xx_hal_dma_ex.c
│ │ │ │ ├── stm32f7xx_hal_flash.c
│ │ │ │ ├── stm32f7xx_hal_flash_ex.c
│ │ │ │ ├── stm32f7xx_hal_gpio.c
│ │ │ │ ├── stm32f7xx_hal_hash.c
│ │ │ │ ├── stm32f7xx_hal_hash_ex.c
│ │ │ │ ├── stm32f7xx_hal_hcd.c
│ │ │ │ ├── stm32f7xx_hal_i2c.c
│ │ │ │ ├── stm32f7xx_hal_i2c_ex.c
│ │ │ │ ├── stm32f7xx_hal_i2s.c
│ │ │ │ ├── stm32f7xx_hal_iwdg.c
│ │ │ │ ├── stm32f7xx_hal_lptim.c
│ │ │ │ ├── stm32f7xx_hal_ltdc.c
│ │ │ │ ├── stm32f7xx_hal_pcd.c
│ │ │ │ ├── stm32f7xx_hal_pcd_ex.c
│ │ │ │ ├── stm32f7xx_hal_pwr.c
│ │ │ │ ├── stm32f7xx_hal_pwr_ex.c
│ │ │ │ ├── stm32f7xx_hal_rcc.c
│ │ │ │ ├── stm32f7xx_hal_rcc_ex.c
│ │ │ │ ├── stm32f7xx_hal_rng.c
│ │ │ │ ├── stm32f7xx_hal_rtc.c
│ │ │ │ ├── stm32f7xx_hal_rtc_ex.c
│ │ │ │ ├── stm32f7xx_hal_sd.c
│ │ │ │ ├── stm32f7xx_hal_spi.c
│ │ │ │ ├── stm32f7xx_hal_tim.c
│ │ │ │ ├── stm32f7xx_hal_uart.c
│ │ │ │ ├── stm32f7xx_hal_usart.c
│ │ │ │ ├── stm32f7xx_hal_wwdg.c
│ │ │ │ ├── stm32f7xx_ll_sdmmc.c
│ │ │ │ └── stm32f7xx_ll_usb.c
│ │ │ ├── main.cpp
│ │ │ ├── pins_arduino.h
│ │ │ ├── variant.cpp
│ │ │ └── variant.h
│ │ └── tools/
│ │ └── opencr_tools_1.0.0/
│ │ ├── linux/
│ │ │ ├── dfu-util/
│ │ │ │ ├── dfu-prefix
│ │ │ │ ├── dfu-suffix
│ │ │ │ └── dfu-util
│ │ │ └── opencr_ld
│ │ ├── linux64/
│ │ │ ├── dfu-util/
│ │ │ │ ├── dfu-prefix
│ │ │ │ ├── dfu-suffix
│ │ │ │ └── dfu-util
│ │ │ └── opencr_ld
│ │ └── macosx/
│ │ ├── dfu-util/
│ │ │ ├── dfu-prefix
│ │ │ ├── dfu-suffix
│ │ │ └── dfu-util
│ │ └── opencr_ld
│ ├── opencr_develop/
│ │ ├── opencr_bootloader/
│ │ │ ├── .cproject
│ │ │ ├── .gitignore
│ │ │ ├── .project
│ │ │ ├── Makefile
│ │ │ ├── bin/
│ │ │ │ └── obj/
│ │ │ │ └── README
│ │ │ ├── common/
│ │ │ │ ├── bsp/
│ │ │ │ │ └── opencr/
│ │ │ │ │ ├── bsp.c
│ │ │ │ │ ├── bsp.h
│ │ │ │ │ ├── button.c
│ │ │ │ │ ├── button.h
│ │ │ │ │ ├── cfg/
│ │ │ │ │ │ ├── startup_stm32f746xx.s
│ │ │ │ │ │ ├── stm32f746xx.h
│ │ │ │ │ │ ├── stm32f7xx.h
│ │ │ │ │ │ ├── stm32f7xx_hal_conf.h
│ │ │ │ │ │ ├── stm32f7xx_it.c
│ │ │ │ │ │ ├── stm32f7xx_it.h
│ │ │ │ │ │ ├── syscalls.c
│ │ │ │ │ │ ├── system_clock.c
│ │ │ │ │ │ ├── system_clock.h
│ │ │ │ │ │ ├── system_stm32f7xx.c
│ │ │ │ │ │ └── system_stm32f7xx.h
│ │ │ │ │ ├── include/
│ │ │ │ │ │ ├── arm_common_tables.h
│ │ │ │ │ │ ├── arm_const_structs.h
│ │ │ │ │ │ ├── arm_math.h
│ │ │ │ │ │ ├── cmsis_armcc.h
│ │ │ │ │ │ ├── cmsis_armcc_V6.h
│ │ │ │ │ │ ├── cmsis_gcc.h
│ │ │ │ │ │ ├── core_cm0.h
│ │ │ │ │ │ ├── core_cm0plus.h
│ │ │ │ │ │ ├── core_cm3.h
│ │ │ │ │ │ ├── core_cm4.h
│ │ │ │ │ │ ├── core_cm7.h
│ │ │ │ │ │ ├── core_cmFunc.h
│ │ │ │ │ │ ├── core_cmInstr.h
│ │ │ │ │ │ ├── core_cmSimd.h
│ │ │ │ │ │ ├── core_sc000.h
│ │ │ │ │ │ └── core_sc300.h
│ │ │ │ │ ├── ld/
│ │ │ │ │ │ └── opencr_flash.ld
│ │ │ │ │ ├── led.c
│ │ │ │ │ ├── led.h
│ │ │ │ │ ├── usbd_cdc.c
│ │ │ │ │ ├── usbd_cdc.h
│ │ │ │ │ ├── usbd_cdc_interface.c
│ │ │ │ │ ├── usbd_cdc_interface.h
│ │ │ │ │ ├── usbd_conf.c
│ │ │ │ │ ├── usbd_conf.h
│ │ │ │ │ ├── usbd_desc.c
│ │ │ │ │ ├── usbd_desc.h
│ │ │ │ │ ├── wdg.c
│ │ │ │ │ └── wdg.h
│ │ │ │ ├── hal/
│ │ │ │ │ ├── def.h
│ │ │ │ │ ├── def_err.h
│ │ │ │ │ ├── delay.c
│ │ │ │ │ ├── delay.h
│ │ │ │ │ ├── flash.c
│ │ │ │ │ ├── flash.h
│ │ │ │ │ ├── hal.c
│ │ │ │ │ ├── hal.h
│ │ │ │ │ ├── msg.c
│ │ │ │ │ ├── msg.h
│ │ │ │ │ ├── util.c
│ │ │ │ │ ├── util.h
│ │ │ │ │ ├── vcp.c
│ │ │ │ │ └── vcp.h
│ │ │ │ ├── lib/
│ │ │ │ │ ├── STM32F7xx_HAL_Driver/
│ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ ├── Legacy/
│ │ │ │ │ │ │ │ └── stm32_hal_legacy.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_adc.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_adc_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_can.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_cec.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_conf_template.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_cortex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_crc.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_crc_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_cryp.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_cryp_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dac.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dac_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dcmi.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dcmi_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_def.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dfsdm.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dma.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dma2d.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dma_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_dsi.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_eth.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_flash.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_flash_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_gpio.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_gpio_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_hash.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_hash_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_hcd.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_i2c.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_i2c_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_i2s.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_irda.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_irda_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_iwdg.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_jpeg.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_lptim.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_ltdc.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_ltdc_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_mdios.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_nand.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_nor.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_pcd.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_pcd_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_pwr.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_pwr_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_qspi.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_rcc.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_rcc_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_rng.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_rtc.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_rtc_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_sai.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_sai_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_sd.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_sdram.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_smartcard.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_smartcard_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_spdifrx.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_spi.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_sram.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_tim.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_tim_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_uart.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_uart_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_usart.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_usart_ex.h
│ │ │ │ │ │ │ ├── stm32f7xx_hal_wwdg.h
│ │ │ │ │ │ │ ├── stm32f7xx_ll_fmc.h
│ │ │ │ │ │ │ ├── stm32f7xx_ll_sdmmc.h
│ │ │ │ │ │ │ └── stm32f7xx_ll_usb.h
│ │ │ │ │ │ ├── Release_Notes.html
│ │ │ │ │ │ └── Src/
│ │ │ │ │ │ ├── stm32f7xx_hal.c
│ │ │ │ │ │ ├── stm32f7xx_hal_adc.c
│ │ │ │ │ │ ├── stm32f7xx_hal_adc_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_can.c
│ │ │ │ │ │ ├── stm32f7xx_hal_cec.c
│ │ │ │ │ │ ├── stm32f7xx_hal_cortex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_crc.c
│ │ │ │ │ │ ├── stm32f7xx_hal_crc_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_cryp.c
│ │ │ │ │ │ ├── stm32f7xx_hal_cryp_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dac.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dac_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dcmi.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dcmi_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dfsdm.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dma.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dma2d.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dma_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_dsi.c
│ │ │ │ │ │ ├── stm32f7xx_hal_eth.c
│ │ │ │ │ │ ├── stm32f7xx_hal_flash.c
│ │ │ │ │ │ ├── stm32f7xx_hal_flash_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_gpio.c
│ │ │ │ │ │ ├── stm32f7xx_hal_hash.c
│ │ │ │ │ │ ├── stm32f7xx_hal_hash_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_hcd.c
│ │ │ │ │ │ ├── stm32f7xx_hal_i2c.c
│ │ │ │ │ │ ├── stm32f7xx_hal_i2c_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_i2s.c
│ │ │ │ │ │ ├── stm32f7xx_hal_irda.c
│ │ │ │ │ │ ├── stm32f7xx_hal_iwdg.c
│ │ │ │ │ │ ├── stm32f7xx_hal_jpeg.c
│ │ │ │ │ │ ├── stm32f7xx_hal_lptim.c
│ │ │ │ │ │ ├── stm32f7xx_hal_ltdc.c
│ │ │ │ │ │ ├── stm32f7xx_hal_ltdc_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_mdios.c
│ │ │ │ │ │ ├── stm32f7xx_hal_msp_template.c
│ │ │ │ │ │ ├── stm32f7xx_hal_nand.c
│ │ │ │ │ │ ├── stm32f7xx_hal_nor.c
│ │ │ │ │ │ ├── stm32f7xx_hal_pcd.c
│ │ │ │ │ │ ├── stm32f7xx_hal_pcd_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_pwr.c
│ │ │ │ │ │ ├── stm32f7xx_hal_pwr_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_qspi.c
│ │ │ │ │ │ ├── stm32f7xx_hal_rcc.c
│ │ │ │ │ │ ├── stm32f7xx_hal_rcc_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_rng.c
│ │ │ │ │ │ ├── stm32f7xx_hal_rtc.c
│ │ │ │ │ │ ├── stm32f7xx_hal_rtc_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_sai.c
│ │ │ │ │ │ ├── stm32f7xx_hal_sai_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_sd.c
│ │ │ │ │ │ ├── stm32f7xx_hal_sdram.c
│ │ │ │ │ │ ├── stm32f7xx_hal_smartcard.c
│ │ │ │ │ │ ├── stm32f7xx_hal_smartcard_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_spdifrx.c
│ │ │ │ │ │ ├── stm32f7xx_hal_spi.c
│ │ │ │ │ │ ├── stm32f7xx_hal_sram.c
│ │ │ │ │ │ ├── stm32f7xx_hal_tim.c
│ │ │ │ │ │ ├── stm32f7xx_hal_tim_ex.c
│ │ │ │ │ │ ├── stm32f7xx_hal_timebase_tim_template.c
│ │ │ │ │ │ ├── stm32f7xx_hal_uart.c
│ │ │ │ │ │ ├── stm32f7xx_hal_usart.c
│ │ │ │ │ │ ├── stm32f7xx_hal_wwdg.c
│ │ │ │ │ │ ├── stm32f7xx_ll_fmc.c
│ │ │ │ │ │ ├── stm32f7xx_ll_sdmmc.c
│ │ │ │ │ │ └── stm32f7xx_ll_usb.c
│ │ │ │ │ └── STM32_USB_Device_Library/
│ │ │ │ │ ├── Class/
│ │ │ │ │ │ ├── AUDIO/
│ │ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ │ ├── usbd_audio.h
│ │ │ │ │ │ │ │ └── usbd_audio_if_template.h
│ │ │ │ │ │ │ └── Src/
│ │ │ │ │ │ │ ├── usbd_audio.c
│ │ │ │ │ │ │ └── usbd_audio_if_template.c
│ │ │ │ │ │ ├── CDC/
│ │ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ │ ├── usbd_cdc.h
│ │ │ │ │ │ │ │ └── usbd_cdc_if_template.h
│ │ │ │ │ │ │ └── Src/
│ │ │ │ │ │ │ └── usbd_cdc.c
│ │ │ │ │ │ ├── CustomHID/
│ │ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ │ ├── usbd_customhid.h
│ │ │ │ │ │ │ │ └── usbd_customhid_if_template.h
│ │ │ │ │ │ │ └── Src/
│ │ │ │ │ │ │ ├── usbd_customhid.c
│ │ │ │ │ │ │ └── usbd_customhid_if_template.c
│ │ │ │ │ │ ├── DFU/
│ │ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ │ ├── usbd_dfu.h
│ │ │ │ │ │ │ │ └── usbd_dfu_media_template.h
│ │ │ │ │ │ │ └── Src/
│ │ │ │ │ │ │ ├── usbd_dfu.c
│ │ │ │ │ │ │ └── usbd_dfu_media_template.c
│ │ │ │ │ │ ├── HID/
│ │ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ │ └── usbd_hid.h
│ │ │ │ │ │ │ └── Src/
│ │ │ │ │ │ │ └── usbd_hid.c
│ │ │ │ │ │ ├── MSC/
│ │ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ │ ├── usbd_msc.h
│ │ │ │ │ │ │ │ ├── usbd_msc_bot.h
│ │ │ │ │ │ │ │ ├── usbd_msc_data.h
│ │ │ │ │ │ │ │ ├── usbd_msc_scsi.h
│ │ │ │ │ │ │ │ └── usbd_msc_storage_template.h
│ │ │ │ │ │ │ └── Src/
│ │ │ │ │ │ │ ├── usbd_msc.c
│ │ │ │ │ │ │ ├── usbd_msc_bot.c
│ │ │ │ │ │ │ ├── usbd_msc_data.c
│ │ │ │ │ │ │ ├── usbd_msc_scsi.c
│ │ │ │ │ │ │ └── usbd_msc_storage_template.c
│ │ │ │ │ │ └── Template/
│ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ └── usbd_template.h
│ │ │ │ │ │ └── Src/
│ │ │ │ │ │ └── usbd_template.c
│ │ │ │ │ ├── Core/
│ │ │ │ │ │ ├── Inc/
│ │ │ │ │ │ │ ├── usbd_conf_template.h
│ │ │ │ │ │ │ ├── usbd_core.h
│ │ │ │ │ │ │ ├── usbd_ctlreq.h
│ │ │ │ │ │ │ ├── usbd_def.h
│ │ │ │ │ │ │ └── usbd_ioreq.h
│ │ │ │ │ │ └── Src/
│ │ │ │ │ │ ├── usbd_core.c
│ │ │ │ │ │ ├── usbd_ctlreq.c
│ │ │ │ │ │ └── usbd_ioreq.c
│ │ │ │ │ └── Release_Notes.html
│ │ │ │ └── msg/
│ │ │ │ ├── mavlink/
│ │ │ │ │ ├── checksum.h
│ │ │ │ │ ├── mavlink_conversions.h
│ │ │ │ │ ├── mavlink_helpers.h
│ │ │ │ │ ├── mavlink_types.h
│ │ │ │ │ ├── opencr_msg/
│ │ │ │ │ │ ├── mavlink.h
│ │ │ │ │ │ ├── mavlink_msg_ack.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_erase.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_read_block.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_read_packet.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_verify.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_begin.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_block.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_end.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_packet.h
│ │ │ │ │ │ ├── mavlink_msg_jump_to_fw.h
│ │ │ │ │ │ ├── mavlink_msg_read_board_name.h
│ │ │ │ │ │ ├── mavlink_msg_read_tag.h
│ │ │ │ │ │ ├── mavlink_msg_read_version.h
│ │ │ │ │ │ ├── opencr_msg.h
│ │ │ │ │ │ ├── testsuite.h
│ │ │ │ │ │ └── version.h
│ │ │ │ │ └── protocol.h
│ │ │ │ └── xml/
│ │ │ │ └── opencr_msg
│ │ │ ├── main.c
│ │ │ ├── main.h
│ │ │ ├── opencr_flash.cfg
│ │ │ ├── opencr_openocd.cfg
│ │ │ └── src/
│ │ │ ├── cmd.c
│ │ │ ├── cmd.h
│ │ │ ├── crc.c
│ │ │ └── crc.h
│ │ ├── opencr_ld/
│ │ │ ├── .cproject
│ │ │ ├── .gitignore
│ │ │ ├── .project
│ │ │ ├── Makefile
│ │ │ ├── README.md
│ │ │ ├── gcc_win/
│ │ │ │ ├── .cproject
│ │ │ │ ├── .gitignore
│ │ │ │ └── .project
│ │ │ ├── images/
│ │ │ │ └── linux_180529/
│ │ │ │ └── opencr_ld.tar.bz2
│ │ │ ├── main.c
│ │ │ ├── msg/
│ │ │ │ ├── def.h
│ │ │ │ ├── def_err.h
│ │ │ │ ├── mavlink/
│ │ │ │ │ ├── checksum.h
│ │ │ │ │ ├── mavlink_conversions.h
│ │ │ │ │ ├── mavlink_helpers.h
│ │ │ │ │ ├── mavlink_types.h
│ │ │ │ │ ├── opencr_msg/
│ │ │ │ │ │ ├── mavlink.h
│ │ │ │ │ │ ├── mavlink_msg_ack.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_erase.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_read_block.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_read_packet.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_verify.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_begin.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_block.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_end.h
│ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_packet.h
│ │ │ │ │ │ ├── mavlink_msg_jump_to_fw.h
│ │ │ │ │ │ ├── mavlink_msg_read_board_name.h
│ │ │ │ │ │ ├── mavlink_msg_read_tag.h
│ │ │ │ │ │ ├── mavlink_msg_read_version.h
│ │ │ │ │ │ ├── opencr_msg.h
│ │ │ │ │ │ ├── testsuite.h
│ │ │ │ │ │ └── version.h
│ │ │ │ │ └── protocol.h
│ │ │ │ ├── msg.c
│ │ │ │ ├── msg.h
│ │ │ │ └── xml/
│ │ │ │ └── opencr_msg
│ │ │ ├── opencr_ld.c
│ │ │ ├── opencr_ld.h
│ │ │ ├── qt_win/
│ │ │ │ └── opencr_ld_win/
│ │ │ │ └── opencr_ld/
│ │ │ │ ├── main.c
│ │ │ │ └── opencr_ld.pro
│ │ │ ├── serial.h
│ │ │ ├── serial_posix.c
│ │ │ ├── serial_win32.c
│ │ │ └── type.h
│ │ └── opencr_ld_shell/
│ │ ├── .cproject
│ │ ├── .gitignore
│ │ ├── .project
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── install_opencr.sh
│ │ ├── main.c
│ │ ├── msg/
│ │ │ ├── def.h
│ │ │ ├── def_err.h
│ │ │ ├── mavlink/
│ │ │ │ ├── checksum.h
│ │ │ │ ├── mavlink_conversions.h
│ │ │ │ ├── mavlink_helpers.h
│ │ │ │ ├── mavlink_types.h
│ │ │ │ ├── opencr_msg/
│ │ │ │ │ ├── mavlink.h
│ │ │ │ │ ├── mavlink_msg_ack.h
│ │ │ │ │ ├── mavlink_msg_flash_fw_erase.h
│ │ │ │ │ ├── mavlink_msg_flash_fw_read_block.h
│ │ │ │ │ ├── mavlink_msg_flash_fw_read_packet.h
│ │ │ │ │ ├── mavlink_msg_flash_fw_verify.h
│ │ │ │ │ ├── mavlink_msg_flash_fw_write_begin.h
│ │ │ │ │ ├── mavlink_msg_flash_fw_write_block.h
│ │ │ │ │ ├── mavlink_msg_flash_fw_write_end.h
│ │ │ │ │ ├── mavlink_msg_flash_fw_write_packet.h
│ │ │ │ │ ├── mavlink_msg_jump_to_fw.h
│ │ │ │ │ ├── mavlink_msg_read_board_name.h
│ │ │ │ │ ├── mavlink_msg_read_tag.h
│ │ │ │ │ ├── mavlink_msg_read_version.h
│ │ │ │ │ ├── opencr_msg.h
│ │ │ │ │ ├── testsuite.h
│ │ │ │ │ └── version.h
│ │ │ │ └── protocol.h
│ │ │ ├── msg.c
│ │ │ ├── msg.h
│ │ │ └── xml/
│ │ │ └── opencr_msg
│ │ ├── opencr_ld.c
│ │ ├── opencr_ld.h
│ │ ├── opencr_ld_shell_arm
│ │ ├── opencr_ld_shell_x86
│ │ ├── qt_win/
│ │ │ └── opencr_ld_win/
│ │ │ └── opencr_ld/
│ │ │ ├── .gitignore
│ │ │ ├── main.c
│ │ │ ├── opencr_ld.pro
│ │ │ └── opencr_ld.pro.user
│ │ ├── serial.h
│ │ ├── serial_posix.c
│ │ ├── serial_win32.c
│ │ ├── type.h
│ │ └── update.sh
│ └── opencr_release/
│ └── package_opencr_index.json
└── install.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/workflows/arduino_ci.yml
================================================
name: Arduino_CI
on:
push:
branches: [ master, develop ]
pull_request:
branches: [ master, develop ]
jobs:
arduino_ci:
runs-on: ubuntu-latest
strategy:
fail-fast: false
steps:
- uses: actions/checkout@v2
- name: install script
run: |
source <(curl -SLs https://raw.githubusercontent.com/ROBOTIS-GIT/OpenCR/master/install.sh) ${{github.ref}}
build_platform opencr
================================================
FILE: .gitignore
================================================
# Compiled Object files
*.slo
*.lo
*.o
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
.vscode
.metadata
================================================
FILE: .project
================================================
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>OpenCR</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
</buildSpec>
<natures>
</natures>
</projectDescription>
================================================
FILE: 49-stlinkv2.rules
================================================
SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="3748", MODE:="0666", SYMLINK+="stlinkv2_%n"
================================================
FILE: 99-opencr-cdc.rules
================================================
#http://linux-tips.org/t/prevent-modem-manager-to-capture-usb-serial-devices/284/2.
#cp rules /etc/udev/rules.d/
#sudo udevadm control --reload-rules
#sudo udevadm trigger
ATTRS{idVendor}=="0483" ATTRS{idProduct}=="5740", ENV{ID_MM_DEVICE_IGNORE}="1", MODE:="0666"
ATTRS{idVendor}=="0483" ATTRS{idProduct}=="df11", MODE:="0666"
ATTRS{idVendor}=="fff1" ATTRS{idProduct}=="ff48", ENV{ID_MM_DEVICE_IGNORE}="1", MODE:="0666"
ATTRS{idVendor}=="10c4" ATTRS{idProduct}=="ea60", ENV{ID_MM_DEVICE_IGNORE}="1", MODE:="0666"
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================
# OpenCR: Open Source Control Module for ROS [](https://travis-ci.org/ROBOTIS-GIT/OpenCR/)
## ROBOTIS e-Manual for OpenCR
- [ROBOTIS e-Manual for OpenCR](http://emanual.robotis.com/docs/en/parts/controller/opencr10/)
## Open Source related to OpenCR
- [Micro ROS Arduino](https://github.com/micro-ROS/micro_ros_arduino)
- [OpenCR](https://github.com/ROBOTIS-GIT/OpenCR)
- [OpenCR-Hardware](https://github.com/ROBOTIS-GIT/OpenCR-Hardware)
- [OpenCM 9.04](https://github.com/ROBOTIS-GIT/OpenCM9.04)
- [dynamixel_sdk](https://github.com/ROBOTIS-GIT/DynamixelSDK)
- [turtlebot3](https://github.com/ROBOTIS-GIT/turtlebot3)
- [open_manipulator](https://github.com/ROBOTIS-GIT/open_manipulator)
- [robotis_op3](https://github.com/ROBOTIS-GIT/ROBOTIS-OP3)
## Documents and Videos related to OpenCR
- [ROBOTIS e-Manual for OpenCR](http://emanual.robotis.com/docs/en/parts/controller/opencr10/)
- [ROBOTIS e-Manual for OpenCM 9.04](http://emanual.robotis.com/docs/en/parts/controller/opencm904/)
- [ROBOTIS e-Manual for OpenCM 485 Expansion Board](http://emanual.robotis.com/docs/en/parts/controller/opencm485exp/)
- [ROBOTIS e-Manual for Dynamixel SDK](http://emanual.robotis.com/docs/en/software/dynamixel/dynamixel_sdk/overview/)
- [ROBOTIS e-Manual for TurtleBot3](http://turtlebot3.robotis.com/)
- [ROBOTIS e-Manual for OpenManipulator](http://emanual.robotis.com/docs/en/platform/openmanipulator/)
- [ROBOTIS e-Manual for ROBOTIS OP3](http://emanual.robotis.com/docs/en/platform/op3/introduction/)
- [Videos for OpenCR](https://www.youtube.com/playlist?list=PLRG6WP3c31_VTd-u90LVXaT1B8NMjCSoj)
## Repository folder structure description
- arduino
- opencr_arduino
- libraries : A collection of some libraries that can be used with OpenCR.
- opencr : OpenCR package core to be installed in Arduino.
- tools : Tools for OpenCR firmware writing.
- opencr_develop
- opencr_bootloader : OpenCR bootloader source
- opencr_ld : OpenCR loader source (related bootloader)
- opencr_ld_shell : OpenCR loader script source for TB3
- opencr_release
- Folders(version name) : Compressed files for updating TB3 core binary with ld_shell for each TB3 core version.
- shell_update : Latest Compressed files for updating TB3 core binary with ld_shell.
- package_opencr_index.json : json file for Arduino OpenCR package.
================================================
FILE: arduino/opencr_arduino/opencr/.gitignore
================================================
.vscode
================================================
FILE: arduino/opencr_arduino/opencr/boards.txt
================================================
# OpenCR Boards
#
menu.device_variant=Variant
menu.bootloader_version=Bootloader version
menu.upload_method=Upload method
OpenCR.bootloader.tool = dfu_util
OpenCR.bootloader.file = opencr_boot.bin
OpenCR.name=OpenCR Board
OpenCR.upload.maximum_size=786432
OpenCR.upload.file_type=bin
OpenCR.upload.ram.maximum_size=256788
OpenCR.upload.flash.maximum_size=786432
OpenCR.upload.params.quiet=no
OpenCR.build.mcu=cortex-m7
OpenCR.build.f_cpu=216000000L
OpenCR.build.board=OpenCR
OpenCR.build.core=arduino
OpenCR.build.common_flags=-mthumb -DSTM32F746xx -D__OPENCR__
OpenCR.build.ldscript=bsp/opencr/ldscript/opencr_flash.ld
OpenCR.build.variant=OpenCR
OpenCR.build.variant_system_lib=lib_f746.a
OpenCR.build.extra_flags=
OpenCR.build.inc1=bsp/opencr
OpenCR.build.inc2=bsp/opencr/include
OpenCR.build.inc3=hw
OpenCR.build.inc4=hw/driver
OpenCR.build.inc5=hw/usb_cdc
OpenCR.build.inc6=lib/STM32F7xx_HAL_Driver/Inc/
OpenCR.build.inc7=
#OpenCR.upload.tool=opencr_ld
#OpenCR.menu.upload_method.upload.tool=opencr_ld
OpenCR.menu.upload_method.UploadMethod=OpenCR Bootloader
OpenCR.menu.upload_method.UploadMethod.upload.protocol=opencr_ld
OpenCR.menu.upload_method.UploadMethod.upload.tool=opencr_ld
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Arduino.h
================================================
/*
Arduino.h - Main include file for the Arduino SDK
Copyright (c) 2005-2013 Arduino Team. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef Arduino_h
#define Arduino_h
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
// some libraries and sketches depend on this
// AVR stuff, assuming Arduino.h or WProgram.h
// automatically includes it...
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include "binary.h"
#include "hw.h"
#include "itoa.h"
#ifdef __cplusplus
extern "C"{
#endif // __cplusplus
#include "chip.h"
#include "wiring_constants.h"
#define clockCyclesPerMicrosecond() ( SystemCoreClock / 1000000L )
#define clockCyclesToMicroseconds(a) ( ((a) * 1000L) / (SystemCoreClock / 1000L) )
#define microsecondsToClockCycles(a) ( (a) * (SystemCoreClock / 1000000L) )
void yield(void);
/* sketch */
extern void setup( void ) ;
extern void loop( void ) ;
//#define NOT_A_PIN 0 // defined in pio.h/EPioType
#define NOT_A_PORT 0
#define NOT_AN_INTERRUPT -1
typedef void (*voidFuncPtr)( void ) ;
/* Define attribute */
#if defined ( __CC_ARM ) /* Keil uVision 4 */
#define WEAK (__attribute__ ((weak)))
#elif defined ( __ICCARM__ ) /* IAR Ewarm 5.41+ */
#define WEAK __weak
#elif defined ( __GNUC__ ) /* GCC CS */
#define WEAK __attribute__ ((weak))
#endif
#ifdef __cplusplus
} // extern "C"
#include "WCharacter.h"
#include "WString.h"
#include "Tone.h"
#include "WMath.h"
#include "HardwareSerial.h"
#include "wiring_pulse.h"
#include "variant.h"
void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0);
void noTone(uint8_t _pin);
#endif // __cplusplus
#include "wiring.h"
#include "wiring_digital.h"
#include "wiring_analog.h"
#include "wiring_shift.h"
#include "WInterrupts.h"
#include "digitalWriteFast.h"
#endif // Arduino_h
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Client.h
================================================
/*
Client.h - Base class that provides Client
Copyright (c) 2011 Adrian McEwen. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef client_h
#define client_h
#include "Print.h"
#include "Stream.h"
#include "IPAddress.h"
class Client : public Stream {
public:
virtual int connect(IPAddress ip, uint16_t port) =0;
virtual int connect(const char *host, uint16_t port) =0;
virtual size_t write(uint8_t) =0;
virtual size_t write(const uint8_t *buf, size_t size) =0;
virtual int available() = 0;
virtual int read() = 0;
virtual int read(uint8_t *buf, size_t size) = 0;
virtual int peek() = 0;
virtual void flush() = 0;
virtual void stop() = 0;
virtual uint8_t connected() = 0;
virtual operator bool() = 0;
protected:
uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
};
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/HardwareSerial.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef HardwareSerial_h
#define HardwareSerial_h
#include <inttypes.h>
#include "Stream.h"
class HardwareSerial : public Stream
{
public:
virtual void begin(unsigned long) = 0;
virtual void end() = 0;
virtual int available(void) = 0;
virtual int peek(void) = 0;
virtual int read(void) = 0;
virtual void flush(void) = 0;
virtual size_t write(uint8_t) = 0;
using Print::write; // pull in write(str) and write(buf, size) from Print
virtual operator bool() = 0;
};
extern void serialEventRun(void) __attribute__((weak));
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/HardwareTimer.cpp
================================================
/******************************************************************************
* The MIT License
*
* Copyright (c) 2010 Bryan Newbold.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*****************************************************************************/
#include <chip.h>
#include <USBSerial.h>
#include "drv_timer.h"
#include "variant.h"
#include "HardwareTimer.h"
#define MAX_RELOAD ((1 << 16) - 1)
HardwareTimer::HardwareTimer(uint8_t timerNum) {
if (timerNum > TIMER_CH_MAX) {
tim_num = 0;
}
tim_num = timerNum;
}
void HardwareTimer::pause(void) {
drv_timer_pause(tim_num);
}
void HardwareTimer::resume(void) {
drv_timer_resume(tim_num);
}
void HardwareTimer::stop(void) {
drv_timer_pause(tim_num);
}
void HardwareTimer::start(void) {
drv_timer_resume(tim_num);
}
uint16_t HardwareTimer::setPeriod(uint32_t microseconds) {
drv_timer_set_period(tim_num, microseconds);
return 0;
}
void HardwareTimer::attachInterrupt(voidFuncPtr handler) {
drv_timer_attachInterrupt(tim_num, handler);
}
void HardwareTimer::detachInterrupt(void) {
drv_timer_detachInterrupt(tim_num);
}
void HardwareTimer::refresh(void) {
drv_timer_refresh(tim_num);
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/HardwareTimer.h
================================================
/******************************************************************************
* The MIT License
*
* Copyright (c) 2010 Bryan Newbold.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*****************************************************************************/
#ifndef _HARDWARETIMER_H_
#define _HARDWARETIMER_H_
#include <inttypes.h>
class HardwareTimer {
private:
uint8_t tim_num;
public:
HardwareTimer(uint8_t timerNum);
void pause(void);
void resume(void);
void stop(void);
void start(void);
uint16_t setPeriod(uint32_t microseconds);
void attachInterrupt(voidFuncPtr handler);
void detachInterrupt(void);
void refresh(void);
};
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/IPAddress.cpp
================================================
/*
IPAddress.cpp - Base class that provides IPAddress
Copyright (c) 2011 Adrian McEwen. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <Arduino.h>
#include <IPAddress.h>
IPAddress::IPAddress()
{
_address.dword = 0;
}
IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet)
{
_address.bytes[0] = first_octet;
_address.bytes[1] = second_octet;
_address.bytes[2] = third_octet;
_address.bytes[3] = fourth_octet;
}
IPAddress::IPAddress(uint32_t address)
{
_address.dword = address;
}
IPAddress::IPAddress(const uint8_t *address)
{
memcpy(_address.bytes, address, sizeof(_address.bytes));
}
bool IPAddress::fromString(const char *address)
{
uint16_t acc = 0; // Accumulator
uint8_t dots = 0;
while (*address)
{
char c = *address++;
if (c >= '0' && c <= '9')
{
acc = acc * 10 + (c - '0');
if (acc > 255) {
// Value out of [0..255] range
return false;
}
}
else if (c == '.')
{
if (dots == 3) {
// Too much dots (there must be 3 dots)
return false;
}
_address.bytes[dots++] = acc;
acc = 0;
}
else
{
// Invalid char
return false;
}
}
if (dots != 3) {
// Too few dots (there must be 3 dots)
return false;
}
_address.bytes[3] = acc;
return true;
}
IPAddress& IPAddress::operator=(const uint8_t *address)
{
memcpy(_address.bytes, address, sizeof(_address.bytes));
return *this;
}
IPAddress& IPAddress::operator=(uint32_t address)
{
_address.dword = address;
return *this;
}
bool IPAddress::operator==(const uint8_t* addr) const
{
return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
}
size_t IPAddress::printTo(Print& p) const
{
size_t n = 0;
for (int i =0; i < 3; i++)
{
n += p.print(_address.bytes[i], DEC);
n += p.print('.');
}
n += p.print(_address.bytes[3], DEC);
return n;
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/IPAddress.h
================================================
/*
IPAddress.h - Base class that provides IPAddress
Copyright (c) 2011 Adrian McEwen. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef IPAddress_h
#define IPAddress_h
#include <stdint.h>
#include "Printable.h"
#include "WString.h"
// A class to make it easier to handle and pass around IP addresses
class IPAddress : public Printable {
private:
union {
uint8_t bytes[4]; // IPv4 address
uint32_t dword;
} _address;
// Access the raw byte array containing the address. Because this returns a pointer
// to the internal structure rather than a copy of the address this function should only
// be used when you know that the usage of the returned uint8_t* will be transient and not
// stored.
uint8_t* raw_address() { return _address.bytes; };
public:
// Constructors
IPAddress();
IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
IPAddress(uint32_t address);
IPAddress(const uint8_t *address);
bool fromString(const char *address);
bool fromString(const String &address) { return fromString(address.c_str()); }
// Overloaded cast operator to allow IPAddress objects to be used where a pointer
// to a four-byte uint8_t array is expected
operator uint32_t() const { return _address.dword; };
bool operator==(const IPAddress& addr) const { return _address.dword == addr._address.dword; };
bool operator==(const uint8_t* addr) const;
// Overloaded index operator to allow getting and setting individual octets of the address
uint8_t operator[](int index) const { return _address.bytes[index]; };
uint8_t& operator[](int index) { return _address.bytes[index]; };
// Overloaded copy operators to allow initialisation of IPAddress objects from other types
IPAddress& operator=(const uint8_t *address);
IPAddress& operator=(uint32_t address);
virtual size_t printTo(Print& p) const;
friend class EthernetClass;
friend class UDP;
friend class Client;
friend class Server;
friend class DhcpClass;
friend class DNSClient;
};
const IPAddress INADDR_NONE(0,0,0,0);
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Print.cpp
================================================
/*
Print.cpp - Base class that provides print() and println()
Copyright (c) 2008 David A. Mellis. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Modified 23 November 2006 by David A. Mellis
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <math.h>
#include "Arduino.h"
#include "Print.h"
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */
size_t Print::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
while (size--) {
n += write(*buffer++);
}
return n;
}
size_t Print::print(const __FlashStringHelper *ifsh)
{
return print(reinterpret_cast<const char *>(ifsh));
}
size_t Print::print(const String &s)
{
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])
{
return write(str);
}
size_t Print::print(char c)
{
return write(c);
}
size_t Print::print(unsigned char b, int base)
{
return print((unsigned long) b, base);
}
size_t Print::print(int n, int base)
{
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)
{
return print((unsigned long) n, base);
}
size_t Print::print(long n, int base)
{
if (base == 0) {
return write(n);
} else if (base == 10) {
if (n < 0) {
int t = print('-');
n = -n;
return printNumber(n, 10) + t;
}
return printNumber(n, 10);
} else {
return printNumber(n, base);
}
}
size_t Print::print(unsigned long n, int base)
{
if (base == 0) return write(n);
else return printNumber(n, base);
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
size_t Print::println(const __FlashStringHelper *ifsh)
{
size_t n = print(ifsh);
n += println();
return n;
}
size_t Print::print(const Printable& x)
{
return x.printTo(*this);
}
size_t Print::println(void)
{
size_t n = print('\r');
n += print('\n');
return n;
}
size_t Print::println(const String &s)
{
size_t n = print(s);
n += println();
return n;
}
size_t Print::println(const char c[])
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(char c)
{
size_t n = print(c);
n += println();
return n;
}
size_t Print::println(unsigned char b, int base)
{
size_t n = print(b, base);
n += println();
return n;
}
size_t Print::println(int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned int num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(unsigned long num, int base)
{
size_t n = print(num, base);
n += println();
return n;
}
size_t Print::println(double num, int digits)
{
size_t n = print(num, digits);
n += println();
return n;
}
size_t Print::println(const Printable& x)
{
size_t n = print(x);
n += println();
return n;
}
size_t Print::printf(const char *fmt, ... )
{
char buf[256]; // resulting string limited to 128 chars
char buf_out[256];
va_list args;
size_t i;
int i_out;
va_start (args, fmt );
vsnprintf(buf, 256, fmt, args);
va_end (args);
i_out = 0;
for( i=0; i<strlen(buf); i++ )
{
if( buf[i] == '\n' )
{
buf_out[i_out++] = '\r';
buf_out[i_out++] = '\n';
}
else
{
buf_out[i_out++] = buf[i];
}
}
buf_out[i_out] = 0;
return write(buf_out, i_out);
}
// Private Methods /////////////////////////////////////////////////////////////
size_t Print::printNumber(unsigned long n, uint8_t base) {
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
char *str = &buf[sizeof(buf) - 1];
*str = '\0';
// prevent crash if called with base == 1
if (base < 2) base = 10;
do {
unsigned long m = n;
n /= base;
char c = m - base * n;
*--str = c < 10 ? c + '0' : c + 'A' - 10;
} while(n);
return write(str);
}
size_t Print::printFloat(double number, uint8_t digits)
{
size_t n = 0;
if (isnan(number)) return print("nan");
if (isinf(number)) return print("inf");
if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
// Handle negative numbers
if (number < 0.0)
{
n += print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i=0; i<digits; ++i)
rounding /= 10.0;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
n += print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits > 0) {
n += print(".");
}
// Extract digits from the remainder one at a time
while (digits-- > 0)
{
remainder *= 10.0;
int toPrint = int(remainder);
n += print(toPrint);
remainder -= toPrint;
}
return n;
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Print.h
================================================
/*
Print.h - Base class that provides print() and println()
Copyright (c) 2008 David A. Mellis. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef Print_h
#define Print_h
#include <inttypes.h>
#include <stdio.h> // for size_t
#include <stdarg.h>
#include "WString.h"
#include "Printable.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
class Print
{
private:
int write_error;
size_t printNumber(unsigned long, uint8_t);
size_t printFloat(double, uint8_t);
protected:
void setWriteError(int err = 1) { write_error = err; }
public:
Print() : write_error(0) {}
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == NULL) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size);
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
size_t printf(const char *fmt, ... );
};
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Printable.h
================================================
/*
Printable.h - Interface class that allows printing of complex types
Copyright (c) 2011 Adrian McEwen. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef Printable_h
#define Printable_h
#include <stdlib.h>
class Print;
/** The Printable class provides a way for new classes to allow themselves to be printed.
By deriving from Printable and implementing the printTo method, it will then be possible
for users to print out instances of this class by passing them into the usual
Print::print and Print::println methods.
*/
class Printable
{
public:
virtual size_t printTo(Print& p) const = 0;
};
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Reset.h
================================================
/*
Copyright (c) 2012 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef RESET_H
#define RESET_H
#ifdef __cplusplus
extern "C" {
#endif
void initiateReset(int ms);
void tickReset();
void cancelReset();
#ifdef __cplusplus
}
#endif
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/RingBuffer.cpp
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "RingBuffer.h"
#include <string.h>
RingBuffer::RingBuffer( void )
{
memset( (void *)_aucBuffer, 0, RING_BUFFER_SIZE ) ;
_iHead=0 ;
_iTail=0 ;
}
void RingBuffer::store_char( uint8_t c )
{
int i = (uint32_t)(_iHead + 1) % RING_BUFFER_SIZE ;
// if we should be storing the received character into the location
// just before the tail (meaning that the head would advance to the
// current location of the tail), we're about to overflow the buffer
// and so we don't write the character or advance the head.
if ( i != _iTail )
{
_aucBuffer[_iHead] = c ;
_iHead = i ;
}
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/RingBuffer.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _RING_BUFFER_
#define _RING_BUFFER_
#include <stdint.h>
// Define constants and variables for buffering incoming serial data. We're
// using a ring buffer (I think), in which head is the index of the location
// to which to write the next incoming character and tail is the index of the
// location from which to read.
#define RING_BUFFER_SIZE 128
class RingBuffer
{
public:
volatile uint8_t _aucBuffer[RING_BUFFER_SIZE] ;
volatile int _iHead ;
volatile int _iTail ;
public:
RingBuffer( void ) ;
void store_char( uint8_t c ) ;
} ;
#endif /* _RING_BUFFER_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Server.h
================================================
/*
Server.h - Base class that provides Server
Copyright (c) 2011 Adrian McEwen. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef server_h
#define server_h
#include "Print.h"
class Server : public Print {
public:
virtual void begin() =0;
};
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Stream.cpp
================================================
/*
Stream.cpp - adds parsing methods to Stream class
Copyright (c) 2008 David A. Mellis. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Created July 2011
parsing functions based on TextFinder library by Michael Margolis
findMulti/findUntil routines written by Jim Leonard/Xuth
*/
#include "Arduino.h"
#include "Stream.h"
#define PARSE_TIMEOUT 1000 // default number of milli-seconds to wait
#define NO_SKIP_CHAR 1 // a magic char not found in a valid ASCII numeric field
// private method to read stream with timeout
int Stream::timedRead()
{
int c;
_startMillis = millis();
do {
c = read();
if (c >= 0) return c;
} while(millis() - _startMillis < _timeout);
return -1; // -1 indicates timeout
}
// private method to peek stream with timeout
int Stream::timedPeek()
{
int c;
_startMillis = millis();
do {
c = peek();
if (c >= 0) return c;
} while(millis() - _startMillis < _timeout);
return -1; // -1 indicates timeout
}
// returns peek of the next digit in the stream or -1 if timeout
// discards non-numeric characters
int Stream::peekNextDigit()
{
int c;
while (1) {
c = timedPeek();
if (c < 0) return c; // timeout
if (c == '-') return c;
if (c >= '0' && c <= '9') return c;
read(); // discard non-numeric
}
}
// Public Methods
//////////////////////////////////////////////////////////////
void Stream::setTimeout(unsigned long timeout) // sets the maximum number of milliseconds to wait
{
_timeout = timeout;
}
// find returns true if the target string is found
bool Stream::find(char *target)
{
return findUntil(target, strlen(target), NULL, 0);
}
// reads data from the stream until the target string of given length is found
// returns true if target string is found, false if timed out
bool Stream::find(char *target, size_t length)
{
return findUntil(target, length, NULL, 0);
}
// as find but search ends if the terminator string is found
bool Stream::findUntil(char *target, char *terminator)
{
return findUntil(target, strlen(target), terminator, strlen(terminator));
}
// reads data from the stream until the target string of the given length is found
// search terminated if the terminator string is found
// returns true if target string is found, false if terminated or timed out
bool Stream::findUntil(char *target, size_t targetLen, char *terminator, size_t termLen)
{
if (terminator == NULL) {
MultiTarget t[1] = {{target, targetLen, 0}};
return findMulti(t, 1) == 0 ? true : false;
} else {
MultiTarget t[2] = {{target, targetLen, 0}, {terminator, termLen, 0}};
return findMulti(t, 2) == 0 ? true : false;
}
}
// returns the first valid (long) integer value from the current position.
// initial characters that are not digits (or the minus sign) are skipped
// function is terminated by the first character that is not a digit.
long Stream::parseInt()
{
return parseInt(NO_SKIP_CHAR); // terminate on first non-digit character (or timeout)
}
// as above but a given skipChar is ignored
// this allows format characters (typically commas) in values to be ignored
long Stream::parseInt(char skipChar)
{
bool isNegative = false;
long value = 0;
int c;
c = peekNextDigit();
// ignore non numeric leading characters
if(c < 0)
return 0; // zero returned if timeout
do{
if(c == skipChar)
; // ignore this charactor
else if(c == '-')
isNegative = true;
else if(c >= '0' && c <= '9') // is c a digit?
value = value * 10 + c - '0';
read(); // consume the character we got with peek
c = timedPeek();
}
while( (c >= '0' && c <= '9') || c == skipChar );
if(isNegative)
value = -value;
return value;
}
// as parseInt but returns a floating point value
float Stream::parseFloat()
{
return parseFloat(NO_SKIP_CHAR);
}
// as above but the given skipChar is ignored
// this allows format characters (typically commas) in values to be ignored
float Stream::parseFloat(char skipChar){
bool isNegative = false;
bool isFraction = false;
long value = 0;
int c;//char c;
float fraction = 1.0;
c = peekNextDigit();
// ignore non numeric leading characters
if(c < 0)
return 0; // zero returned if timeout
do{
if(c == skipChar)
; // ignore
else if(c == '-')
isNegative = true;
else if (c == '.')
isFraction = true;
else if(c >= '0' && c <= '9') { // is c a digit?
value = value * 10 + c - '0';
if(isFraction)
fraction *= 0.1;
}
read(); // consume the character we got with peek
c = timedPeek();
}
while( (c >= '0' && c <= '9') || c == '.' || c == skipChar );
if(isNegative)
value = -value;
if(isFraction)
return value * fraction;
else
return value;
}
// read characters from stream into buffer
// terminates if length characters have been read, or timeout (see setTimeout)
// returns the number of characters placed in the buffer
// the buffer is NOT null terminated.
//
size_t Stream::readBytes(char *buffer, size_t length)
{
size_t count = 0;
while (count < length) {
int c = timedRead();
if (c < 0) break;
*buffer++ = (char)c;
count++;
}
return count;
}
// as readBytes with terminator character
// terminates if length characters have been read, timeout, or if the terminator character detected
// returns the number of characters placed in the buffer (0 means no valid data found)
size_t Stream::readBytesUntil(char terminator, char *buffer, size_t length)
{
if (length < 1) return 0;
size_t index = 0;
while (index < length) {
int c = timedRead();
if (c < 0 || c == terminator) break;
*buffer++ = (char)c;
index++;
}
return index; // return number of characters, not including null terminator
}
String Stream::readString()
{
String ret;
int c = timedRead();
while (c >= 0)
{
ret += (char)c;
c = timedRead();
}
return ret;
}
String Stream::readStringUntil(char terminator)
{
String ret;
int c = timedRead();
while (c >= 0 && c != terminator)
{
ret += (char)c;
c = timedRead();
}
return ret;
}
int Stream::findMulti( struct Stream::MultiTarget *targets, int tCount) {
// any zero length target string automatically matches and would make
// a mess of the rest of the algorithm.
for (struct MultiTarget *t = targets; t < targets+tCount; ++t) {
if (t->len <= 0)
return t - targets;
}
while (1) {
int c = timedRead();
if (c < 0)
return -1;
for (struct MultiTarget *t = targets; t < targets+tCount; ++t) {
// the simple case is if we match, deal with that first.
if (c == t->str[t->index]) {
if (++t->index == t->len)
return t - targets;
else
continue;
}
// if not we need to walk back and see if we could have matched further
// down the stream (ie '1112' doesn't match the first position in '11112'
// but it will match the second position so we can't just reset the current
// index to 0 when we find a mismatch.
if (t->index == 0)
continue;
int origIndex = t->index;
do {
--t->index;
// first check if current char works against the new current index
if (c != t->str[t->index])
continue;
// if it's the only char then we're good, nothing more to check
if (t->index == 0) {
t->index++;
break;
}
// otherwise we need to check the rest of the found string
int diff = origIndex - t->index;
size_t i;
for (i = 0; i < t->index; ++i) {
if (t->str[i] != t->str[i + diff])
break;
}
// if we successfully got through the previous loop then our current
// index is good.
if (i == t->index) {
t->index++;
break;
}
// otherwise we just try the next index
} while (t->index);
}
}
// unreachable
return -1;
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Stream.h
================================================
/*
Stream.h - base class for character-based streams.
Copyright (c) 2010 David A. Mellis. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
parsing functions based on TextFinder library by Michael Margolis
*/
#ifndef Stream_h
#define Stream_h
#include <inttypes.h>
#include "Print.h"
// compatability macros for testing
/*
#define getInt() parseInt()
#define getInt(skipChar) parseInt(skipchar)
#define getFloat() parseFloat()
#define getFloat(skipChar) parseFloat(skipChar)
#define getString( pre_string, post_string, buffer, length)
readBytesBetween( pre_string, terminator, buffer, length)
*/
class Stream : public Print
{
protected:
unsigned long _timeout; // number of milliseconds to wait for the next char before aborting timed read
unsigned long _startMillis; // used for timeout measurement
int timedRead(); // private method to read stream with timeout
int timedPeek(); // private method to peek stream with timeout
int peekNextDigit(); // returns the next numeric digit in the stream or -1 if timeout
public:
virtual int available() = 0;
virtual int read() = 0;
virtual int peek() = 0;
virtual void flush() = 0;
Stream() {_timeout=1000;}
// parsing methods
void setTimeout(unsigned long timeout); // sets maximum milliseconds to wait for stream data, default is 1 second
bool find(char *target); // reads data from the stream until the target string is found
bool find(uint8_t *target) { return find ((char *)target); }
// returns true if target string is found, false if timed out (see setTimeout)
bool find(char *target, size_t length); // reads data from the stream until the target string of given length is found
bool find(uint8_t *target, size_t length) { return find ((char *)target, length); }
// returns true if target string is found, false if timed out
bool findUntil(char *target, char *terminator); // as find but search ends if the terminator string is found
bool findUntil(uint8_t *target, char *terminator) { return findUntil((char *)target, terminator); }
bool findUntil(char *target, size_t targetLen, char *terminate, size_t termLen); // as above but search ends if the terminate string is found
bool findUntil(uint8_t *target, size_t targetLen, char *terminate, size_t termLen) {return findUntil((char *)target, targetLen, terminate, termLen); }
long parseInt(); // returns the first valid (long) integer value from the current position.
// initial characters that are not digits (or the minus sign) are skipped
// integer is terminated by the first character that is not a digit.
float parseFloat(); // float version of parseInt
size_t readBytes( char *buffer, size_t length); // read chars from stream into buffer
size_t readBytes( uint8_t *buffer, size_t length) { return readBytes((char *)buffer, length); }
// terminates if length characters have been read or timeout (see setTimeout)
// returns the number of characters placed in the buffer (0 means no valid data found)
size_t readBytesUntil( char terminator, char *buffer, size_t length); // as readBytes with terminator character
size_t readBytesUntil( char terminator, uint8_t *buffer, size_t length) { return readBytesUntil(terminator, (char *)buffer, length); }
// terminates if length characters have been read, timeout, or if the terminator character detected
// returns the number of characters placed in the buffer (0 means no valid data found)
// Arduino String functions to be added here
String readString();
String readStringUntil(char terminator);
protected:
long parseInt(char skipChar); // as above but the given skipChar is ignored
// as above but the given skipChar is ignored
// this allows format characters (typically commas) in values to be ignored
float parseFloat(char skipChar); // as above but the given skipChar is ignored
struct MultiTarget {
const char *str; // string you're searching for
size_t len; // length of string you're searching for
size_t index; // index used by the search routine.
};
// This allows you to search for an arbitrary number of strings.
// Returns index of the target that is found first or -1 if timeout occurs.
int findMulti(struct MultiTarget *targets, int tCount);
};
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Tone.cpp
================================================
/* Tone.cpp
A Tone Generator Library
Written by Brett Hagman
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Version Modified By Date Comments
------- ----------- -------- --------
0001 B Hagman 09/08/02 Initial coding
0002 B Hagman 09/08/18 Multiple pins
0003 B Hagman 09/08/18 Moved initialization from constructor to begin()
0004 B Hagman 09/09/26 Fixed problems with ATmega8
0005 B Hagman 09/11/23 Scanned prescalars for best fit on 8 bit timers
09/11/25 Changed pin toggle method to XOR
09/11/25 Fixed timer0 from being excluded
0006 D Mellis 09/12/29 Replaced objects with functions
0007 M Sproul 10/08/29 Changed #ifdefs from cpu to register
0008 S Kanemoto 12/06/22 Fixed for Leonardo by @maris_HY
0009 J Reucker 15/04/10 Issue #292 Fixed problems with ATmega8 (thanks to Pete62)
0010 jipp 15/04/13 added additional define check #2923
0011 Baram 16/10/06 fixed for OpenCR
*************************************************/
#include <chip.h>
#include "variant.h"
#include "Tone.h"
// timerx_toggle_count:
// > 0 - duration specified
// = 0 - stopped
// < 0 - infinitely (until stop() method called, or new play() called)
volatile int32_t tone_toggle_count;
volatile uint8_t tone_timer = TIMER_TONE;
volatile uint8_t tone_pin;
volatile uint8_t tone_pin_out;
volatile bool tone_enable = false;
void tone_isr( void );
static void toneBegin(uint8_t _pin)
{
tone_pin = _pin;
tone_pin_out = 0;
tone_enable = true;
}
static void toneEnd(void)
{
tone_enable = false;
tone_pin_out = 0;
drv_timer_pause(tone_timer);
}
// frequency (in hertz) and duration (in milliseconds).
void tone(uint8_t _pin, unsigned int frequency, unsigned long duration)
{
//uint8_t prescalarbits = 0b001;
long toggle_count = 0;
uint32_t ocr = 0;
//int8_t _timer;
// Set the pinMode as OUTPUT
pinMode(_pin, OUTPUT);
digitalWrite(_pin, 0);
ocr = (1000000 / frequency) / 2 ;
// Calculate the toggle count
if (duration > 0)
{
toggle_count = 2 * frequency * duration / 1000;
}
else
{
toggle_count = -1;
}
tone_toggle_count = toggle_count;
toneBegin(_pin);
drv_timer_set_period(tone_timer, ocr);
drv_timer_attachInterrupt(tone_timer, tone_isr);
drv_timer_resume(tone_timer);
}
void noTone(uint8_t _pin)
{
toneEnd();
digitalWrite(_pin, 0);
}
void tone_isr( void )
{
if (tone_toggle_count != 0)
{
// toggle the pin
tone_pin_out ^= 1;
digitalWrite(tone_pin, tone_pin_out);
if(tone_toggle_count > 0)
{
tone_toggle_count--;
}
}
else
{
toneEnd();
}
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Tone.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_TONE_
#define _WIRING_TONE_
#endif /* _WIRING_TONE_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/UARTClass.cpp
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "UARTClass.h"
#include "wiring_digital.h"
#include "wiring_constants.h"
#include "variant.h"
#include "digitalWriteFast.h"
// Constructors ////////////////////////////////////////////////////////////////
UARTClass::UARTClass(void){
}
UARTClass::UARTClass(uint8_t uart_num, uint8_t uart_mode, uint8_t *txBuffer, uint16_t tx_buffer_size)
{
_uart_num = uart_num;
_uart_mode = uart_mode;
_uart_baudrate = 0;
rx_cnt = 0;
tx_cnt = 0;
tx_write_size = 0;
tx_buffer.buffer = txBuffer;
tx_buffer.buffer_size = tx_buffer_size;
}
void UARTClass::begin(const uint32_t dwBaudRate)
{
begin(dwBaudRate, Mode_8N1);
}
void UARTClass::begin(const uint32_t dwBaudRate, const UARTModes config)
{
UNUSED(config);
#ifdef DRV_UART_RX_DMA_ONLY
rx_buffer.iHead = rx_buffer.iTail = 0;
#endif
tx_buffer.iHead = 0;
tx_buffer.iTail = 0;
_uart_baudrate = dwBaudRate;
drv_uart_begin(_uart_num, _uart_mode, dwBaudRate);
}
void UARTClass::end( void )
{
// Clear any received data
#ifdef DRV_UART_RX_DMA_ONLY
rx_buffer.iHead = rx_buffer.iTail;
#endif
// Wait for any outstanding data to be sent
flush();
}
int UARTClass::available( void )
{
#ifdef DRV_UART_RX_DMA_ONLY
if(drv_uart_get_mode(_uart_num) == DRV_UART_IRQ_MODE )
{
return (uint32_t)(SERIAL_BUFFER_SIZE + rx_buffer.iHead - rx_buffer.iTail) % SERIAL_BUFFER_SIZE;
}
else
{
return drv_uart_available(_uart_num);
}
#else
return drv_uart_available(_uart_num);
#endif
}
int UARTClass::availableForWrite(void)
{
int head = tx_buffer.iHead;
int tail = tx_buffer.iTail;
if (head >= tail) return SERIAL_BUFFER_SIZE - 1 - head + tail;
return tail - head - 1;
}
int UARTClass::peek( void )
{
#ifdef DRV_UART_RX_DMA_ONLY
if(drv_uart_get_mode(_uart_num) == DRV_UART_IRQ_MODE )
{
if ( rx_buffer.iHead == rx_buffer.iTail )
return -1;
return rx_buffer.buffer[rx_buffer.iTail];
}
else
{
return drv_uart_peek(_uart_num);
}
#else
return drv_uart_peek(_uart_num);
#endif
}
int UARTClass::read( void )
{
#ifdef DRV_UART_RX_DMA_ONLY
if(drv_uart_get_mode(_uart_num) == DRV_UART_IRQ_MODE )
{
// if the head isn't ahead of the tail, we don't have any characters
if ( rx_buffer.iHead == rx_buffer.iTail )
return -1;
uint8_t uc = rx_buffer.buffer[rx_buffer.iTail];
rx_buffer.iTail = (unsigned int)(rx_buffer.iTail + 1) % SERIAL_BUFFER_SIZE;
rx_cnt++;
return uc;
}
else
{
int return_value = drv_uart_read(_uart_num);
if (return_value != -1)
{
rx_cnt++;
}
return return_value;
}
#else
int return_value = drv_uart_read(_uart_num);
if (return_value != -1)
{
rx_cnt++;
}
return return_value;
#endif
}
void UARTClass::flush( void )
{
while (tx_write_size); //wait for transmit data to be sent
}
void UARTClass::flushRx( uint32_t timeout_ms )
{
#ifdef DRV_UART_RX_DMA_ONLY
if(drv_uart_get_mode(_uart_num) == DRV_UART_IRQ_MODE )
{
// sort of hack, wait the time specified and then just clear it
if (timeout_ms)
{
uint32_t pre_time_ms = millis();
while((millis() - pre_time_ms) < timeout_ms)
{
}
}
rx_buffer.iTail = rx_buffer.iHead; // clear out buffer
}
else
{
drv_uart_rx_flush(_uart_num, timeout_ms);
}
#else
drv_uart_rx_flush(_uart_num, timeout_ms);
#endif
}
size_t UARTClass::write( const uint8_t uc_data )
{
return write(&uc_data, 1); // Lets call the buffer function to do the main work
}
void inline UARTClass::startNextTransmitDMAorIT()
{
tx_write_size = (tx_buffer.iTail < tx_buffer.iHead)? tx_buffer.iHead-tx_buffer.iTail : tx_buffer.buffer_size - tx_buffer.iTail;
if (drv_uart_write_dma_it(_uart_num, &tx_buffer.buffer[tx_buffer.iTail], tx_write_size) != 0)
{
tx_write_size = 0; // error so clear it out
}
}
size_t UARTClass::write( const uint8_t *buffer, size_t size )
{
tx_cnt += size;
size_t cbLeft = size;
// Lets try to put as much of this data into our TX buffer as possible.
while (cbLeft--)
{
uint16_t nextWrite = (tx_buffer.iHead + 1) % tx_buffer.buffer_size;
if (tx_buffer.iTail == nextWrite)
{
// See if we have an active TX or not
if (!tx_write_size)
{
startNextTransmitDMAorIT();
}
// right now this will wait for the entire previous write to complete before continue...
while (tx_buffer.iTail == nextWrite)
{
}
}
tx_buffer.buffer[tx_buffer.iHead] = *buffer++;
tx_buffer.iHead = nextWrite;
}
// we finished putting stuff on queue, so see if we need to start up write
// or if it is already going.
if (!tx_write_size)
{
startNextTransmitDMAorIT();
}
return size;
}
uint32_t UARTClass::getBaudRate( void )
{
return _uart_baudrate;
}
uint32_t UARTClass::getRxCnt(void)
{
return rx_cnt;
}
uint32_t UARTClass::getTxCnt(void)
{
return tx_cnt;
}
void UARTClass::RxHandler (void)
{
#ifdef DRV_UART_RX_DMA_ONLY
if( _uart_mode == DRV_UART_IRQ_MODE )
{
if(available() < (SERIAL_BUFFER_SIZE - 1))
{
drv_uart_read_buf(_uart_num, &r_byte, 1);
rx_buffer.buffer[rx_buffer.iHead] = r_byte;
rx_buffer.iHead = (uint16_t)(rx_buffer.iHead + 1) % SERIAL_BUFFER_SIZE;
}
drv_uart_start_rx(_uart_num);
}
#endif
}
void UARTClass::TxHandler(void)
{
// We completed previous write, so update our tail pointer by count
tx_buffer.iTail += tx_write_size;
if (tx_buffer.iTail >= tx_buffer.buffer_size)
tx_buffer.iTail = 0; // Should only wrap to start by our other stuff...
if (tx_buffer.iHead != tx_buffer.iTail)
{
startNextTransmitDMAorIT();
}
else
{
// finished all outstanding writes so lets set count to 0
tx_write_size = 0;
}
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/UARTClass.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _UART_CLASS_
#define _UART_CLASS_
#include "HardwareSerial.h"
#include <chip.h>
#define SERIAL_8N1 UARTClass::Mode_8N1
#define SERIAL_8E1 UARTClass::Mode_8E1
#define SERIAL_8O1 UARTClass::Mode_8O1
#define SERIAL_8M1 UARTClass::Mode_8M1
#define SERIAL_8S1 UARTClass::Mode_8S1
#define SERIAL_BUFFER_SIZE 2048
#define SERIAL_WRITES_NON_BLOCKING 1
class UARTClass : public HardwareSerial
{
public:
enum UARTModes {
Mode_8N1 = 0, // = US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_NO,
Mode_8E1, // = US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_EVEN,
Mode_8O1, // = US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_ODD,
Mode_8M1, // = US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_MARK,
Mode_8S1 // = US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_SPACE,
};
UARTClass(uint8_t uart_num, uint8_t uart_mode, uint8_t *txBuffer, uint16_t tx_buffer_size);
UARTClass(void);
void begin(const uint32_t dwBaudRate);
void begin(const uint32_t dwBaudRate, const UARTModes config);
void end(void);
int available(void);
int availableForWrite(void);
int peek(void);
int read(void);
void flush(void);
void flushRx( uint32_t timeout_ms );
size_t write(const uint8_t c);
size_t write(const uint8_t *buffer, size_t size);
using Print::write; // pull in write(str) and write(buf, size) from Print
void RxHandler(void); /* Vassilis Serasidis */
void TxHandler(void); /* Vassilis Serasidis */
uint32_t getBaudRate(void);
uint32_t getRxCnt(void);
uint32_t getTxCnt(void);
operator bool() { return true; }; // UART always active
protected:
void inline startNextTransmitDMAorIT(void);
#ifdef DRV_UART_RX_DMA_ONLY
struct ring_buffer
{
uint8_t buffer[SERIAL_BUFFER_SIZE];
volatile uint16_t iHead;
volatile uint16_t iTail;
};
#endif
struct tx_no_cache_buffer
{
uint8_t *buffer;
uint16_t buffer_size;
volatile uint16_t iHead;
volatile uint16_t iTail;
};
uint8_t _uart_num;
uint8_t _uart_mode;
uint32_t _uart_baudrate;
uint8_t r_byte;
volatile uint16_t tx_write_size;
tx_no_cache_buffer tx_buffer;
#ifdef DRV_UART_RX_DMA_ONLY
ring_buffer rx_buffer;
#endif
uint32_t rx_cnt;
uint32_t tx_cnt;
};
#endif // _UART_CLASS_
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/USBSerial.cpp
================================================
/****************************************************************************
*
* USBSerial core library for Arduino STM32 + HAL + CubeMX (HALMX).
*
* Copyright (c) 2016 by Vassilis Serasidis <info@serasidis.gr>
* Home: http://www.serasidis.gr
* email: avrsite@yahoo.gr
*
* Arduino_STM32 forum: http://www.stm32duino.com
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all copies.
*
* Some functions follow the sam and samd arduino core libray files.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
*
****************************************************************************/
/*
* Modified on: 2016. 7.12.
* Author: Baram, PBHP
*/
#include <chip.h>
#include <USBSerial.h>
#include "variant.h"
extern uint32_t usb_cdc_bitrate;
extern uint32_t usb_cdc_debug_cnt[];
USBSerial::USBSerial(){
baudrate = 0;
rx_cnt = 0;
tx_cnt = 0;
rx_err_cnt = 0;
tx_err_cnt = 0;
}
void USBSerial::begin(uint32_t baud_count){
UNUSED(baud_count);
}
void USBSerial::begin(uint32_t baud_count, uint8_t config){
UNUSED(baud_count);
UNUSED(config);
}
void USBSerial::end(void){
}
int USBSerial::available(void){
return vcp_is_available();
}
int USBSerial::peek(void)
{
return vcp_peek();
}
int USBSerial::read(void)
{
if ( vcp_is_available() == 0 )
return -1;
rx_cnt++;
return vcp_getch();
}
void USBSerial::flush(void){
while( vcp_is_transmitted() == FALSE );
}
size_t USBSerial::write(const uint8_t *buffer, size_t size)
{
uint32_t length;
length = vcp_write((uint8_t *)buffer, (uint32_t)size);
tx_cnt += length;
return (size_t)length;
}
size_t USBSerial::write(uint8_t c) {
return write(&c, 1);
}
uint32_t USBSerial::getBaudRate(void)
{
return usb_cdc_bitrate;
}
uint32_t USBSerial::getRxCnt(void)
{
return rx_cnt;
}
uint32_t USBSerial::getTxCnt(void)
{
return tx_cnt;
}
uint32_t USBSerial::getRxErrCnt(void)
{
return usb_cdc_debug_cnt[0];
}
uint32_t USBSerial::getTxErrCnt(void)
{
return usb_cdc_debug_cnt[1];
}
// This operator is a convenient way for a sketch to check whether the
// port has actually been configured and opened by the host (as opposed
// to just being connected to the host). It can be used, for example, in
// setup() before printing to ensure that an application on the host is
// actually ready to receive and display the data.
// We add a short delay before returning to fix a bug observed by Federico
// where the port is configured (lineState != 0) but not quite opened.
USBSerial::operator bool()
{
if( vcp_is_connected() == TRUE ) return true;
else return false;
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/USBSerial.h
================================================
/****************************************************************************
*
* USBSerial core library for Arduino STM32 + HAL + CubeMX (HALMX).
*
* Copyright (c) 2016 by Vassilis Serasidis <info@serasidis.gr>
* Home: http://www.serasidis.gr
* email: avrsite@yahoo.gr
*
* Arduino_STM32 forum: http://www.stm32duino.com
*
* The USBSerial.h file follows the function prototypes of
* the Arduino CDC.h file that was written by Peter Barrett
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
*
****************************************************************************/
/*
* Modified on: 2016. 7.12.
* Author: Baram, PBHP
*/
#ifndef _SERIAL_USB_H_INCLUDED
#define _SERIAL_USB_H_INCLUDED
#include <chip.h>
#include "RingBuffer.h"
#include "Stream.h"
#include "chip.h"
class USBSerial : public Stream {
public:
USBSerial();
void begin(uint32_t baud_count);
void begin(uint32_t baud_count, uint8_t config);
void end(void);
virtual int available(void);
//virtual void accept(void);
virtual int peek(void);
virtual int read(void);
virtual void flush(void);
virtual size_t write(uint8_t c);
virtual size_t write(const uint8_t *buffer, size_t size);
using Print::write; // pull in write(str) from Print
operator bool();
uint32_t getBaudRate(void);
uint32_t getRxCnt(void);
uint32_t getTxCnt(void);
uint32_t getRxErrCnt(void);
uint32_t getTxErrCnt(void);
private:
uint32_t baudrate;
uint32_t rx_cnt;
uint32_t tx_cnt;
uint32_t rx_err_cnt;
uint32_t tx_err_cnt;
};
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/Udp.h
================================================
/*
* Udp.cpp: Library to send/receive UDP packets.
*
* NOTE: UDP is fast, but has some important limitations (thanks to Warren Gray for mentioning these)
* 1) UDP does not guarantee the order in which assembled UDP packets are received. This
* might not happen often in practice, but in larger network topologies, a UDP
* packet can be received out of sequence.
* 2) UDP does not guard against lost packets - so packets *can* disappear without the sender being
* aware of it. Again, this may not be a concern in practice on small local networks.
* For more information, see http://www.cafeaulait.org/course/week12/35.html
*
* MIT License:
* Copyright (c) 2008 Bjoern Hartmann
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* bjoern@cs.stanford.edu 12/30/2008
*/
#ifndef udp_h
#define udp_h
#include <Stream.h>
#include <IPAddress.h>
class UDP : public Stream {
public:
virtual uint8_t begin(uint16_t) =0; // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
virtual void stop() =0; // Finish with the UDP socket
// Sending UDP packets
// Start building up a packet to send to the remote host specific in ip and port
// Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
virtual int beginPacket(IPAddress ip, uint16_t port) =0;
// Start building up a packet to send to the remote host specific in host and port
// Returns 1 if successful, 0 if there was a problem resolving the hostname or port
virtual int beginPacket(const char *host, uint16_t port) =0;
// Finish off this packet and send it
// Returns 1 if the packet was sent successfully, 0 if there was an error
virtual int endPacket() =0;
// Write a single byte into the packet
virtual size_t write(uint8_t) =0;
// Write size bytes from buffer into the packet
virtual size_t write(const uint8_t *buffer, size_t size) =0;
// Start processing the next available incoming packet
// Returns the size of the packet in bytes, or 0 if no packets are available
virtual int parsePacket() =0;
// Number of bytes remaining in the current packet
virtual int available() =0;
// Read a single byte from the current packet
virtual int read() =0;
// Read up to len bytes from the current packet and place them into buffer
// Returns the number of bytes read, or 0 if none are available
virtual int read(unsigned char* buffer, size_t len) =0;
// Read up to len characters from the current packet and place them into buffer
// Returns the number of characters read, or 0 if none are available
virtual int read(char* buffer, size_t len) =0;
// Return the next byte from the current packet without moving on to the next byte
virtual int peek() =0;
virtual void flush() =0; // Finish reading the current packet
// Return the IP address of the host who sent the current incoming packet
virtual IPAddress remoteIP() =0;
// Return the port of the host who sent the current incoming packet
virtual uint16_t remotePort() =0;
protected:
uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
};
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/WCharacter.h
================================================
/*
WCharacter.h - Character utility functions for Wiring & Arduino
Copyright (c) 2010 Hernando Barragan. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef Character_h
#define Character_h
#include <ctype.h>
#ifdef __cplusplus
extern "C" {
#endif
// WCharacter.h prototypes
#if defined ( __GNUC__ )
inline boolean isAlphaNumeric(int c) __attribute__((always_inline));
inline boolean isAlpha(int c) __attribute__((always_inline));
inline boolean isAscii(int c) __attribute__((always_inline));
inline boolean isWhitespace(int c) __attribute__((always_inline));
inline boolean isControl(int c) __attribute__((always_inline));
inline boolean isDigit(int c) __attribute__((always_inline));
inline boolean isGraph(int c) __attribute__((always_inline));
inline boolean isLowerCase(int c) __attribute__((always_inline));
inline boolean isPrintable(int c) __attribute__((always_inline));
inline boolean isPunct(int c) __attribute__((always_inline));
inline boolean isSpace(int c) __attribute__((always_inline));
inline boolean isUpperCase(int c) __attribute__((always_inline));
inline boolean isHexadecimalDigit(int c) __attribute__((always_inline));
inline int toAscii(int c) __attribute__((always_inline));
inline int toLowerCase(int c) __attribute__((always_inline));
inline int toUpperCase(int c)__attribute__((always_inline));
#elif defined ( __ICCARM__ )
#endif
// Checks for an alphanumeric character.
// It is equivalent to (isalpha(c) || isdigit(c)).
inline boolean isAlphaNumeric(int c)
{
return ( isalnum(c) == 0 ? false : true);
}
// Checks for an alphabetic character.
// It is equivalent to (isupper(c) || islower(c)).
inline boolean isAlpha(int c)
{
return ( isalpha(c) == 0 ? false : true);
}
// Checks whether c is a 7-bit unsigned char value
// that fits into the ASCII character set.
inline boolean isAscii(int c)
{
/* return ( isascii(c) == 0 ? false : true); */
return ( (c & ~0x7f) != 0 ? false : true);
}
// Checks for a blank character, that is, a space or a tab.
inline boolean isWhitespace(int c)
{
return ( isblank (c) == 0 ? false : true);
}
// Checks for a control character.
inline boolean isControl(int c)
{
return ( iscntrl (c) == 0 ? false : true);
}
// Checks for a digit (0 through 9).
inline boolean isDigit(int c)
{
return ( isdigit (c) == 0 ? false : true);
}
// Checks for any printable character except space.
inline boolean isGraph(int c)
{
return ( isgraph (c) == 0 ? false : true);
}
// Checks for a lower-case character.
inline boolean isLowerCase(int c)
{
return (islower (c) == 0 ? false : true);
}
// Checks for any printable character including space.
inline boolean isPrintable(int c)
{
return ( isprint (c) == 0 ? false : true);
}
// Checks for any printable character which is not a space
// or an alphanumeric character.
inline boolean isPunct(int c)
{
return ( ispunct (c) == 0 ? false : true);
}
// Checks for white-space characters. For the avr-libc library,
// these are: space, formfeed ('\f'), newline ('\n'), carriage
// return ('\r'), horizontal tab ('\t'), and vertical tab ('\v').
inline boolean isSpace(int c)
{
return ( isspace (c) == 0 ? false : true);
}
// Checks for an uppercase letter.
inline boolean isUpperCase(int c)
{
return ( isupper (c) == 0 ? false : true);
}
// Checks for a hexadecimal digits, i.e. one of 0 1 2 3 4 5 6 7
// 8 9 a b c d e f A B C D E F.
inline boolean isHexadecimalDigit(int c)
{
return ( isxdigit (c) == 0 ? false : true);
}
// Converts c to a 7-bit unsigned char value that fits into the
// ASCII character set, by clearing the high-order bits.
inline int toAscii(int c)
{
/* return toascii (c); */
return (c & 0x7f);
}
// Warning:
// Many people will be unhappy if you use this function.
// This function will convert accented letters into random
// characters.
// Converts the letter c to lower case, if possible.
inline int toLowerCase(int c)
{
return tolower (c);
}
// Converts the letter c to upper case, if possible.
inline int toUpperCase(int c)
{
return toupper (c);
}
#ifdef __cplusplus
}
#endif
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/WInterrupts.c
================================================
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "WInterrupts.h"
#include "variant.h"
#include "wiring_digital.h"
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* \brief Specifies a named Interrupt Service Routine (ISR) to call when an interrupt occurs.
* Replaces any previous function that was attached to the interrupt.
*/
void attachInterrupt( uint32_t pin, voidFuncPtr callback, uint32_t ulMode )
{
drv_exti_attach( pin, callback, ulMode );
}
/*
* \brief Turns off the given interrupt.
*/
void detachInterrupt( uint32_t pin )
{
drv_exti_detach( pin );
}
#ifdef __cplusplus
}
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/WInterrupts.h
================================================
/*
Copyright (c) 2011-2012 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_INTERRUPTS_
#define _WIRING_INTERRUPTS_
#include "Arduino.h"
#ifdef __cplusplus
extern "C" {
#endif
void attachInterrupt(uint32_t pin, void (*callback)(void), uint32_t mode);
void detachInterrupt(uint32_t pin);
#ifdef __cplusplus
}
#endif
#endif /* _WIRING_INTERRUPTS_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/WMath.cpp
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
extern "C" {
#include "stdlib.h"
#include "stdint.h"
}
#include "WMath.h"
extern void randomSeed( uint32_t dwSeed )
{
if ( dwSeed != 0 )
{
srand( dwSeed ) ;
}
}
extern long random( long howbig )
{
if ( howbig == 0 )
{
return 0 ;
}
return rand() % howbig;
}
extern long random( long howsmall, long howbig )
{
if (howsmall >= howbig)
{
return howsmall;
}
long diff = howbig - howsmall;
return random(diff) + howsmall;
}
extern long map(long x, long in_min, long in_max, long out_min, long out_max)
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
extern uint16_t makeWord( uint16_t w )
{
return w ;
}
extern uint16_t makeWord( uint8_t h, uint8_t l )
{
return (h << 8) | l ;
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/WMath.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_MATH_
#define _WIRING_MATH_
extern long random( long ) ;
extern long random( long, long ) ;
extern void randomSeed( uint32_t dwSeed ) ;
extern long map( long, long, long, long, long ) ;
extern uint16_t makeWord( uint16_t w ) ;
extern uint16_t makeWord( uint8_t h, uint8_t l ) ;
#define word(...) makeWord(__VA_ARGS__)
#endif /* _WIRING_MATH_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/WString.cpp
================================================
/*
WString.cpp - String library for Wiring & Arduino
...mostly rewritten by Paul Stoffregen...
Copyright (c) 2009-10 Hernando Barragan. All rights reserved.
Copyright 2011, Paul Stoffregen, paul@pjrc.com
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "WString.h"
#include "itoa.h"
#include "avr/dtostrf.h"
/*********************************************/
/* Constructors */
/*********************************************/
String::String(const char *cstr)
{
init();
if (cstr) copy(cstr, strlen(cstr));
}
String::String(const String &value)
{
init();
*this = value;
}
String::String(const __FlashStringHelper *pstr)
{
init();
*this = pstr;
}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
String::String(String &&rval)
{
init();
move(rval);
}
String::String(StringSumHelper &&rval)
{
init();
move(rval);
}
#endif
String::String(char c)
{
init();
char buf[2];
buf[0] = c;
buf[1] = 0;
*this = buf;
}
String::String(unsigned char value, unsigned char base)
{
init();
char buf[1 + 8 * sizeof(unsigned char)];
utoa(value, buf, base);
*this = buf;
}
String::String(int value, unsigned char base)
{
init();
char buf[2 + 8 * sizeof(int)];
itoa(value, buf, base);
*this = buf;
}
String::String(unsigned int value, unsigned char base)
{
init();
char buf[1 + 8 * sizeof(unsigned int)];
utoa(value, buf, base);
*this = buf;
}
String::String(long value, unsigned char base)
{
init();
char buf[2 + 8 * sizeof(long)];
ltoa(value, buf, base);
*this = buf;
}
String::String(unsigned long value, unsigned char base)
{
init();
char buf[1 + 8 * sizeof(unsigned long)];
ultoa(value, buf, base);
*this = buf;
}
String::String(float value, unsigned char decimalPlaces)
{
init();
char buf[33];
*this = dtostrf(value, (decimalPlaces + 2), decimalPlaces, buf);
}
String::String(double value, unsigned char decimalPlaces)
{
init();
char buf[33];
*this = dtostrf(value, (decimalPlaces + 2), decimalPlaces, buf);
}
String::~String()
{
free(buffer);
}
/*********************************************/
/* Memory Management */
/*********************************************/
inline void String::init(void)
{
buffer = NULL;
capacity = 0;
len = 0;
}
void String::invalidate(void)
{
if (buffer) free(buffer);
buffer = NULL;
capacity = len = 0;
}
unsigned char String::reserve(unsigned int size)
{
if (buffer && capacity >= size) return 1;
if (changeBuffer(size)) {
if (len == 0) buffer[0] = 0;
return 1;
}
return 0;
}
unsigned char String::changeBuffer(unsigned int maxStrLen)
{
char *newbuffer = (char *)realloc(buffer, maxStrLen + 1);
if (newbuffer) {
buffer = newbuffer;
capacity = maxStrLen;
return 1;
}
return 0;
}
/*********************************************/
/* Copy and Move */
/*********************************************/
String & String::copy(const char *cstr, unsigned int length)
{
if (!reserve(length)) {
invalidate();
return *this;
}
len = length;
strcpy(buffer, cstr);
return *this;
}
String & String::copy(const __FlashStringHelper *pstr, unsigned int length)
{
if (!reserve(length)) {
invalidate();
return *this;
}
len = length;
strcpy_P(buffer, (PGM_P)pstr);
return *this;
}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
void String::move(String &rhs)
{
if (buffer) {
if (capacity >= rhs.len) {
strcpy(buffer, rhs.buffer);
len = rhs.len;
rhs.len = 0;
return;
} else {
free(buffer);
}
}
buffer = rhs.buffer;
capacity = rhs.capacity;
len = rhs.len;
rhs.buffer = NULL;
rhs.capacity = 0;
rhs.len = 0;
}
#endif
String & String::operator = (const String &rhs)
{
if (this == &rhs) return *this;
if (rhs.buffer) copy(rhs.buffer, rhs.len);
else invalidate();
return *this;
}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
String & String::operator = (String &&rval)
{
if (this != &rval) move(rval);
return *this;
}
String & String::operator = (StringSumHelper &&rval)
{
if (this != &rval) move(rval);
return *this;
}
#endif
String & String::operator = (const char *cstr)
{
if (cstr) copy(cstr, strlen(cstr));
else invalidate();
return *this;
}
String & String::operator = (const __FlashStringHelper *pstr)
{
if (pstr) copy(pstr, strlen_P((PGM_P)pstr));
else invalidate();
return *this;
}
/*********************************************/
/* concat */
/*********************************************/
unsigned char String::concat(const String &s)
{
return concat(s.buffer, s.len);
}
#if 1
unsigned char String::concat(const char *cstr, unsigned int length)
{
unsigned int newlen = len + length;
if (!cstr) return 0;
if (length == 0) return 1;
if (!reserve(newlen)) return 0;
strcpy(buffer + len, cstr);
len = newlen;
return 1;
}
unsigned char String::concat(const char *cstr)
{
if (!cstr) return 0;
return concat(cstr, strlen(cstr));
}
unsigned char String::concat(char c)
{
char buf[2];
buf[0] = c;
buf[1] = 0;
return concat(buf, 1);
}
unsigned char String::concat(unsigned char num)
{
char buf[1 + 3 * sizeof(unsigned char)];
itoa(num, buf, 10);
return concat(buf, strlen(buf));
}
unsigned char String::concat(int num)
{
char buf[2 + 3 * sizeof(int)];
itoa(num, buf, 10);
return concat(buf, strlen(buf));
}
unsigned char String::concat(unsigned int num)
{
char buf[1 + 3 * sizeof(unsigned int)];
utoa(num, buf, 10);
return concat(buf, strlen(buf));
}
unsigned char String::concat(long num)
{
char buf[2 + 3 * sizeof(long)];
ltoa(num, buf, 10);
return concat(buf, strlen(buf));
}
unsigned char String::concat(unsigned long num)
{
char buf[1 + 3 * sizeof(unsigned long)];
ultoa(num, buf, 10);
return concat(buf, strlen(buf));
}
unsigned char String::concat(float num)
{
char buf[20];
char* string = dtostrf(num, 4, 2, buf);
return concat(string, strlen(string));
}
unsigned char String::concat(double num)
{
char buf[20];
char* string = dtostrf(num, 4, 2, buf);
return concat(string, strlen(string));
}
unsigned char String::concat(const __FlashStringHelper * str)
{
if (!str) return 0;
int length = strlen_P((const char *) str);
if (length == 0) return 1;
unsigned int newlen = len + length;
if (!reserve(newlen)) return 0;
strcpy_P(buffer + len, (const char *) str);
len = newlen;
return 1;
}
/*********************************************/
/* Concatenate */
/*********************************************/
StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(rhs.buffer, rhs.len)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!cstr || !a.concat(cstr, strlen(cstr))) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, char c)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(c)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(num)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, int num)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(num)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(num)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, long num)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(num)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(num)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, float num)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(num)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, double num)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(num)) a.invalidate();
return a;
}
StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs)
{
StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
if (!a.concat(rhs)) a.invalidate();
return a;
}
#endif
/*********************************************/
/* Comparison */
/*********************************************/
int String::compareTo(const String &s) const
{
if (!buffer || !s.buffer) {
if (s.buffer && s.len > 0) return 0 - *(unsigned char *)s.buffer;
if (buffer && len > 0) return *(unsigned char *)buffer;
return 0;
}
return strcmp(buffer, s.buffer);
}
unsigned char String::equals(const String &s2) const
{
return (len == s2.len && compareTo(s2) == 0);
}
unsigned char String::equals(const char *cstr) const
{
if (len == 0) return (cstr == NULL || *cstr == 0);
if (cstr == NULL) return buffer[0] == 0;
return strcmp(buffer, cstr) == 0;
}
unsigned char String::operator<(const String &rhs) const
{
return compareTo(rhs) < 0;
}
unsigned char String::operator>(const String &rhs) const
{
return compareTo(rhs) > 0;
}
unsigned char String::operator<=(const String &rhs) const
{
return compareTo(rhs) <= 0;
}
unsigned char String::operator>=(const String &rhs) const
{
return compareTo(rhs) >= 0;
}
unsigned char String::equalsIgnoreCase( const String &s2 ) const
{
if (this == &s2) return 1;
if (len != s2.len) return 0;
if (len == 0) return 1;
const char *p1 = buffer;
const char *p2 = s2.buffer;
while (*p1) {
if (tolower(*p1++) != tolower(*p2++)) return 0;
}
return 1;
}
unsigned char String::startsWith( const String &s2 ) const
{
if (len < s2.len) return 0;
return startsWith(s2, 0);
}
unsigned char String::startsWith( const String &s2, unsigned int offset ) const
{
if (offset > len - s2.len || !buffer || !s2.buffer) return 0;
return strncmp( &buffer[offset], s2.buffer, s2.len ) == 0;
}
unsigned char String::endsWith( const String &s2 ) const
{
if ( len < s2.len || !buffer || !s2.buffer) return 0;
return strcmp(&buffer[len - s2.len], s2.buffer) == 0;
}
/*********************************************/
/* Character Access */
/*********************************************/
char String::charAt(unsigned int loc) const
{
return operator[](loc);
}
void String::setCharAt(unsigned int loc, char c)
{
if (loc < len) buffer[loc] = c;
}
char & String::operator[](unsigned int index)
{
static char dummy_writable_char;
if (index >= len || !buffer) {
dummy_writable_char = 0;
return dummy_writable_char;
}
return buffer[index];
}
char String::operator[]( unsigned int index ) const
{
if (index >= len || !buffer) return 0;
return buffer[index];
}
void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index) const
{
if (!bufsize || !buf) return;
if (index >= len) {
buf[0] = 0;
return;
}
unsigned int n = bufsize - 1;
if (n > len - index) n = len - index;
strncpy((char *)buf, buffer + index, n);
buf[n] = 0;
}
/*********************************************/
/* Search */
/*********************************************/
int String::indexOf(char c) const
{
return indexOf(c, 0);
}
int String::indexOf( char ch, unsigned int fromIndex ) const
{
if (fromIndex >= len) return -1;
const char* temp = strchr(buffer + fromIndex, ch);
if (temp == NULL) return -1;
return temp - buffer;
}
int String::indexOf(const String &s2) const
{
return indexOf(s2, 0);
}
int String::indexOf(const String &s2, unsigned int fromIndex) const
{
if (fromIndex >= len) return -1;
const char *found = strstr(buffer + fromIndex, s2.buffer);
if (found == NULL) return -1;
return found - buffer;
}
int String::lastIndexOf( char theChar ) const
{
return lastIndexOf(theChar, len - 1);
}
int String::lastIndexOf(char ch, unsigned int fromIndex) const
{
if (fromIndex >= len) return -1;
char tempchar = buffer[fromIndex + 1];
buffer[fromIndex + 1] = '\0';
char* temp = strrchr( buffer, ch );
buffer[fromIndex + 1] = tempchar;
if (temp == NULL) return -1;
return temp - buffer;
}
int String::lastIndexOf(const String &s2) const
{
return lastIndexOf(s2, len - s2.len);
}
int String::lastIndexOf(const String &s2, unsigned int fromIndex) const
{
if (s2.len == 0 || len == 0 || s2.len > len) return -1;
if (fromIndex >= len) fromIndex = len - 1;
int found = -1;
for (char *p = buffer; p <= buffer + fromIndex; p++) {
p = strstr(p, s2.buffer);
if (!p) break;
if ((unsigned int)(p - buffer) <= fromIndex) found = p - buffer;
}
return found;
}
String String::substring(unsigned int left, unsigned int right) const
{
if (left > right) {
unsigned int temp = right;
right = left;
left = temp;
}
String out;
if (left >= len) return out;
if (right > len) right = len;
char temp = buffer[right]; // save the replaced character
buffer[right] = '\0';
out = buffer + left; // pointer arithmetic
buffer[right] = temp; //restore character
return out;
}
/*********************************************/
/* Modification */
/*********************************************/
void String::replace(char find, char replace)
{
if (!buffer) return;
for (char *p = buffer; *p; p++) {
if (*p == find) *p = replace;
}
}
void String::replace(const String& find, const String& replace)
{
if (len == 0 || find.len == 0) return;
int diff = replace.len - find.len;
char *readFrom = buffer;
char *foundAt;
if (diff == 0) {
while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
memcpy(foundAt, replace.buffer, replace.len);
readFrom = foundAt + replace.len;
}
} else if (diff < 0) {
char *writeTo = buffer;
while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
unsigned int n = foundAt - readFrom;
memcpy(writeTo, readFrom, n);
writeTo += n;
memcpy(writeTo, replace.buffer, replace.len);
writeTo += replace.len;
readFrom = foundAt + find.len;
len += diff;
}
strcpy(writeTo, readFrom);
} else {
unsigned int size = len; // compute size needed for result
while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
readFrom = foundAt + find.len;
size += diff;
}
if (size == len) return;
if (size > capacity && !changeBuffer(size)) return; // XXX: tell user!
int index = len - 1;
while (index >= 0 && (index = lastIndexOf(find, index)) >= 0) {
readFrom = buffer + index + find.len;
memmove(readFrom + diff, readFrom, len - (readFrom - buffer));
len += diff;
buffer[len] = 0;
memcpy(buffer + index, replace.buffer, replace.len);
index--;
}
}
}
void String::remove(unsigned int index){
// Pass the biggest integer as the count. The remove method
// below will take care of truncating it at the end of the
// string.
remove(index, (unsigned int)-1);
}
void String::remove(unsigned int index, unsigned int count){
if (index >= len) { return; }
if (count <= 0) { return; }
if (count > len - index) { count = len - index; }
char *writeTo = buffer + index;
len = len - count;
strncpy(writeTo, buffer + index + count,len - index);
buffer[len] = 0;
}
void String::toLowerCase(void)
{
if (!buffer) return;
for (char *p = buffer; *p; p++) {
*p = tolower(*p);
}
}
void String::toUpperCase(void)
{
if (!buffer) return;
for (char *p = buffer; *p; p++) {
*p = toupper(*p);
}
}
void String::trim(void)
{
if (!buffer || len == 0) return;
char *begin = buffer;
while (isspace(*begin)) begin++;
char *end = buffer + len - 1;
while (isspace(*end) && end >= begin) end--;
len = end + 1 - begin;
if (begin > buffer) memcpy(buffer, begin, len);
buffer[len] = 0;
}
/*********************************************/
/* Parsing / Conversion */
/*********************************************/
long String::toInt(void) const
{
if (buffer) return atol(buffer);
return 0;
}
float String::toFloat(void) const
{
if (buffer) return float(atof(buffer));
return 0;
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/WString.h
================================================
/*
WString.h - String library for Wiring & Arduino
...mostly rewritten by Paul Stoffregen...
Copyright (c) 2009-10 Hernando Barragan. All right reserved.
Copyright 2011, Paul Stoffregen, paul@pjrc.com
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef String_class_h
#define String_class_h
#ifdef __cplusplus
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <avr/pgmspace.h>
// When compiling programs with this class, the following gcc parameters
// dramatically increase performance and memory (RAM) efficiency, typically
// with little or no increase in code size.
// -felide-constructors
// -std=c++0x
class __FlashStringHelper;
#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
// An inherited class for holding the result of a concatenation. These
// result objects are assumed to be writable by subsequent concatenations.
class StringSumHelper;
// The string class
class String
{
// use a function pointer to allow for "if (s)" without the
// complications of an operator bool(). for more information, see:
// http://www.artima.com/cppsource/safebool.html
typedef void (String::*StringIfHelperType)() const;
void StringIfHelper() const {}
public:
// constructors
// creates a copy of the initial value.
// if the initial value is null or invalid, or if memory allocation
// fails, the string will be marked as invalid (i.e. "if (s)" will
// be false).
String(const char *cstr = "");
String(const String &str);
String(const __FlashStringHelper *str);
#ifdef __GXX_EXPERIMENTAL_CXX0X__
String(String &&rval);
String(StringSumHelper &&rval);
#endif
explicit String(char c);
explicit String(unsigned char, unsigned char base=10);
explicit String(int, unsigned char base=10);
explicit String(unsigned int, unsigned char base=10);
explicit String(long, unsigned char base=10);
explicit String(unsigned long, unsigned char base=10);
explicit String(float, unsigned char decimalPlaces=2);
explicit String(double, unsigned char decimalPlaces=2);
~String(void);
// memory management
// return true on success, false on failure (in which case, the string
// is left unchanged). reserve(0), if successful, will validate an
// invalid string (i.e., "if (s)" will be true afterwards)
unsigned char reserve(unsigned int size);
inline unsigned int length(void) const {return len;}
// creates a copy of the assigned value. if the value is null or
// invalid, or if the memory allocation fails, the string will be
// marked as invalid ("if (s)" will be false).
String & operator = (const String &rhs);
String & operator = (const char *cstr);
String & operator = (const __FlashStringHelper *str);
#ifdef __GXX_EXPERIMENTAL_CXX0X__
String & operator = (String &&rval);
String & operator = (StringSumHelper &&rval);
#endif
// concatenate (works w/ built-in types)
// returns true on success, false on failure (in which case, the string
// is left unchanged). if the argument is null or invalid, the
// concatenation is considered unsucessful.
unsigned char concat(const String &str);
unsigned char concat(const char *cstr);
unsigned char concat(char c);
unsigned char concat(unsigned char c);
unsigned char concat(int num);
unsigned char concat(unsigned int num);
unsigned char concat(long num);
unsigned char concat(unsigned long num);
unsigned char concat(float num);
unsigned char concat(double num);
unsigned char concat(const __FlashStringHelper * str);
// if there's not enough memory for the concatenated value, the string
// will be left unchanged (but this isn't signalled in any way)
String & operator += (const String &rhs) {concat(rhs); return (*this);}
String & operator += (const char *cstr) {concat(cstr); return (*this);}
String & operator += (char c) {concat(c); return (*this);}
String & operator += (unsigned char num) {concat(num); return (*this);}
String & operator += (int num) {concat(num); return (*this);}
String & operator += (unsigned int num) {concat(num); return (*this);}
String & operator += (long num) {concat(num); return (*this);}
String & operator += (unsigned long num) {concat(num); return (*this);}
String & operator += (float num) {concat(num); return (*this);}
String & operator += (double num) {concat(num); return (*this);}
String & operator += (const __FlashStringHelper *str){concat(str); return (*this);}
friend StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs);
#if 1
friend StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr);
friend StringSumHelper & operator + (const StringSumHelper &lhs, char c);
friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, int num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, long num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, float num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, double num);
friend StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs);
#endif
// comparison (only works w/ Strings and "strings")
operator StringIfHelperType() const { return buffer ? &String::StringIfHelper : 0; }
int compareTo(const String &s) const;
unsigned char equals(const String &s) const;
unsigned char equals(const char *cstr) const;
unsigned char operator == (const String &rhs) const {return equals(rhs);}
unsigned char operator == (const char *cstr) const {return equals(cstr);}
unsigned char operator != (const String &rhs) const {return !equals(rhs);}
unsigned char operator != (const char *cstr) const {return !equals(cstr);}
unsigned char operator < (const String &rhs) const;
unsigned char operator > (const String &rhs) const;
unsigned char operator <= (const String &rhs) const;
unsigned char operator >= (const String &rhs) const;
unsigned char equalsIgnoreCase(const String &s) const;
unsigned char startsWith( const String &prefix) const;
unsigned char startsWith(const String &prefix, unsigned int offset) const;
unsigned char endsWith(const String &suffix) const;
// character acccess
char charAt(unsigned int index) const;
void setCharAt(unsigned int index, char c);
char operator [] (unsigned int index) const;
char& operator [] (unsigned int index);
void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const;
void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const
{getBytes((unsigned char *)buf, bufsize, index);}
const char * c_str() const { return buffer; }
// search
int indexOf( char ch ) const;
int indexOf( char ch, unsigned int fromIndex ) const;
int indexOf( const String &str ) const;
int indexOf( const String &str, unsigned int fromIndex ) const;
int lastIndexOf( char ch ) const;
int lastIndexOf( char ch, unsigned int fromIndex ) const;
int lastIndexOf( const String &str ) const;
int lastIndexOf( const String &str, unsigned int fromIndex ) const;
String substring( unsigned int beginIndex ) const { return substring(beginIndex, len); };
String substring( unsigned int beginIndex, unsigned int endIndex ) const;
// modification
void replace(char find, char replace);
void replace(const String& find, const String& replace);
void remove(unsigned int index);
void remove(unsigned int index, unsigned int count);
void toLowerCase(void);
void toUpperCase(void);
void trim(void);
// parsing/conversion
long toInt(void) const;
float toFloat(void) const;
protected:
char *buffer; // the actual char array
unsigned int capacity; // the array length minus one (for the '\0')
unsigned int len; // the String length (not counting the '\0')
protected:
void init(void);
void invalidate(void);
unsigned char changeBuffer(unsigned int maxStrLen);
unsigned char concat(const char *cstr, unsigned int length);
// copy and move
String & copy(const char *cstr, unsigned int length);
String & copy(const __FlashStringHelper *pstr, unsigned int length);
#ifdef __GXX_EXPERIMENTAL_CXX0X__
void move(String &rhs);
#endif
};
class StringSumHelper : public String
{
public:
StringSumHelper(const String &s) : String(s) {}
StringSumHelper(const char *p) : String(p) {}
StringSumHelper(char c) : String(c) {}
StringSumHelper(unsigned char num) : String(num) {}
StringSumHelper(int num) : String(num) {}
StringSumHelper(unsigned int num) : String(num) {}
StringSumHelper(long num) : String(num) {}
StringSumHelper(unsigned long num) : String(num) {}
StringSumHelper(float num) : String(num) {}
StringSumHelper(double num) : String(num) {}
};
#endif // __cplusplus
#endif // String_class_h
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/avr/dtostrf.c
================================================
/*
dtostrf - Emulation for dtostrf function from avr-libc
Copyright (c) 2013 Arduino. All rights reserved.
Written by Cristian Maglie <c.maglie@arduino.cc>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
char *dtostrf (double val, signed char width, unsigned char prec, char *sout) {
int val_int = (int)val;
int decimal_value = (int)(val * pow(10, prec)) - val_int * pow(10, prec);
sprintf(sout, "%d.%d", val_int, abs(decimal_value));
return sout;
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/avr/dtostrf.h
================================================
/*
dtostrf - Emulation for dtostrf function from avr-libc
Copyright (c) 2013 Arduino. All rights reserved.
Written by Cristian Maglie <c.maglie@arduino.cc>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifdef __cplusplus
extern "C" {
#endif
char *dtostrf (double val, signed char width, unsigned char prec, char *sout);
#ifdef __cplusplus
}
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/avr/interrupt.h
================================================
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/avr/pgmspace.h
================================================
#ifndef __PGMSPACE_H_
#define __PGMSPACE_H_ 1
#include <inttypes.h>
#define PROGMEM
#define PGM_P const char *
#define PSTR(str) (str)
#define _SFR_BYTE(n) (n)
typedef void prog_void;
typedef char prog_char;
typedef unsigned char prog_uchar;
typedef int8_t prog_int8_t;
typedef uint8_t prog_uint8_t;
typedef int16_t prog_int16_t;
typedef uint16_t prog_uint16_t;
typedef int32_t prog_int32_t;
typedef uint32_t prog_uint32_t;
#define memcpy_P(dest, src, num) memcpy((dest), (src), (num))
#define strcpy_P(dest, src) strcpy((dest), (src))
#define strcat_P(dest, src) strcat((dest), (src))
#define strcmp_P(a, b) strcmp((a), (b))
#define strstr_P(a, b) strstr((a), (b))
#define strlen_P(a) strlen((a))
#define sprintf_P(s, f, ...) sprintf((s), (f), __VA_ARGS__)
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#define pgm_read_float(addr) (*(const float *)(addr))
#define pgm_read_byte_near(addr) pgm_read_byte(addr)
#define pgm_read_word_near(addr) pgm_read_word(addr)
#define pgm_read_dword_near(addr) pgm_read_dword(addr)
#define pgm_read_float_near(addr) pgm_read_float(addr)
#define pgm_read_byte_far(addr) pgm_read_byte(addr)
#define pgm_read_word_far(addr) pgm_read_word(addr)
#define pgm_read_dword_far(addr) pgm_read_dword(addr)
#define pgm_read_float_far(addr) pgm_read_float(addr)
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/binary.h
================================================
/*
binary.h - Definitions for binary constants
Copyright (c) 2006 David A. Mellis. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef Binary_h
#define Binary_h
#define B0 0
#define B00 0
#define B000 0
#define B0000 0
#define B00000 0
#define B000000 0
#define B0000000 0
#define B00000000 0
#define B1 1
#define B01 1
#define B001 1
#define B0001 1
#define B00001 1
#define B000001 1
#define B0000001 1
#define B00000001 1
#define B10 2
#define B010 2
#define B0010 2
#define B00010 2
#define B000010 2
#define B0000010 2
#define B00000010 2
#define B11 3
#define B011 3
#define B0011 3
#define B00011 3
#define B000011 3
#define B0000011 3
#define B00000011 3
#define B100 4
#define B0100 4
#define B00100 4
#define B000100 4
#define B0000100 4
#define B00000100 4
#define B101 5
#define B0101 5
#define B00101 5
#define B000101 5
#define B0000101 5
#define B00000101 5
#define B110 6
#define B0110 6
#define B00110 6
#define B000110 6
#define B0000110 6
#define B00000110 6
#define B111 7
#define B0111 7
#define B00111 7
#define B000111 7
#define B0000111 7
#define B00000111 7
#define B1000 8
#define B01000 8
#define B001000 8
#define B0001000 8
#define B00001000 8
#define B1001 9
#define B01001 9
#define B001001 9
#define B0001001 9
#define B00001001 9
#define B1010 10
#define B01010 10
#define B001010 10
#define B0001010 10
#define B00001010 10
#define B1011 11
#define B01011 11
#define B001011 11
#define B0001011 11
#define B00001011 11
#define B1100 12
#define B01100 12
#define B001100 12
#define B0001100 12
#define B00001100 12
#define B1101 13
#define B01101 13
#define B001101 13
#define B0001101 13
#define B00001101 13
#define B1110 14
#define B01110 14
#define B001110 14
#define B0001110 14
#define B00001110 14
#define B1111 15
#define B01111 15
#define B001111 15
#define B0001111 15
#define B00001111 15
#define B10000 16
#define B010000 16
#define B0010000 16
#define B00010000 16
#define B10001 17
#define B010001 17
#define B0010001 17
#define B00010001 17
#define B10010 18
#define B010010 18
#define B0010010 18
#define B00010010 18
#define B10011 19
#define B010011 19
#define B0010011 19
#define B00010011 19
#define B10100 20
#define B010100 20
#define B0010100 20
#define B00010100 20
#define B10101 21
#define B010101 21
#define B0010101 21
#define B00010101 21
#define B10110 22
#define B010110 22
#define B0010110 22
#define B00010110 22
#define B10111 23
#define B010111 23
#define B0010111 23
#define B00010111 23
#define B11000 24
#define B011000 24
#define B0011000 24
#define B00011000 24
#define B11001 25
#define B011001 25
#define B0011001 25
#define B00011001 25
#define B11010 26
#define B011010 26
#define B0011010 26
#define B00011010 26
#define B11011 27
#define B011011 27
#define B0011011 27
#define B00011011 27
#define B11100 28
#define B011100 28
#define B0011100 28
#define B00011100 28
#define B11101 29
#define B011101 29
#define B0011101 29
#define B00011101 29
#define B11110 30
#define B011110 30
#define B0011110 30
#define B00011110 30
#define B11111 31
#define B011111 31
#define B0011111 31
#define B00011111 31
#define B100000 32
#define B0100000 32
#define B00100000 32
#define B100001 33
#define B0100001 33
#define B00100001 33
#define B100010 34
#define B0100010 34
#define B00100010 34
#define B100011 35
#define B0100011 35
#define B00100011 35
#define B100100 36
#define B0100100 36
#define B00100100 36
#define B100101 37
#define B0100101 37
#define B00100101 37
#define B100110 38
#define B0100110 38
#define B00100110 38
#define B100111 39
#define B0100111 39
#define B00100111 39
#define B101000 40
#define B0101000 40
#define B00101000 40
#define B101001 41
#define B0101001 41
#define B00101001 41
#define B101010 42
#define B0101010 42
#define B00101010 42
#define B101011 43
#define B0101011 43
#define B00101011 43
#define B101100 44
#define B0101100 44
#define B00101100 44
#define B101101 45
#define B0101101 45
#define B00101101 45
#define B101110 46
#define B0101110 46
#define B00101110 46
#define B101111 47
#define B0101111 47
#define B00101111 47
#define B110000 48
#define B0110000 48
#define B00110000 48
#define B110001 49
#define B0110001 49
#define B00110001 49
#define B110010 50
#define B0110010 50
#define B00110010 50
#define B110011 51
#define B0110011 51
#define B00110011 51
#define B110100 52
#define B0110100 52
#define B00110100 52
#define B110101 53
#define B0110101 53
#define B00110101 53
#define B110110 54
#define B0110110 54
#define B00110110 54
#define B110111 55
#define B0110111 55
#define B00110111 55
#define B111000 56
#define B0111000 56
#define B00111000 56
#define B111001 57
#define B0111001 57
#define B00111001 57
#define B111010 58
#define B0111010 58
#define B00111010 58
#define B111011 59
#define B0111011 59
#define B00111011 59
#define B111100 60
#define B0111100 60
#define B00111100 60
#define B111101 61
#define B0111101 61
#define B00111101 61
#define B111110 62
#define B0111110 62
#define B00111110 62
#define B111111 63
#define B0111111 63
#define B00111111 63
#define B1000000 64
#define B01000000 64
#define B1000001 65
#define B01000001 65
#define B1000010 66
#define B01000010 66
#define B1000011 67
#define B01000011 67
#define B1000100 68
#define B01000100 68
#define B1000101 69
#define B01000101 69
#define B1000110 70
#define B01000110 70
#define B1000111 71
#define B01000111 71
#define B1001000 72
#define B01001000 72
#define B1001001 73
#define B01001001 73
#define B1001010 74
#define B01001010 74
#define B1001011 75
#define B01001011 75
#define B1001100 76
#define B01001100 76
#define B1001101 77
#define B01001101 77
#define B1001110 78
#define B01001110 78
#define B1001111 79
#define B01001111 79
#define B1010000 80
#define B01010000 80
#define B1010001 81
#define B01010001 81
#define B1010010 82
#define B01010010 82
#define B1010011 83
#define B01010011 83
#define B1010100 84
#define B01010100 84
#define B1010101 85
#define B01010101 85
#define B1010110 86
#define B01010110 86
#define B1010111 87
#define B01010111 87
#define B1011000 88
#define B01011000 88
#define B1011001 89
#define B01011001 89
#define B1011010 90
#define B01011010 90
#define B1011011 91
#define B01011011 91
#define B1011100 92
#define B01011100 92
#define B1011101 93
#define B01011101 93
#define B1011110 94
#define B01011110 94
#define B1011111 95
#define B01011111 95
#define B1100000 96
#define B01100000 96
#define B1100001 97
#define B01100001 97
#define B1100010 98
#define B01100010 98
#define B1100011 99
#define B01100011 99
#define B1100100 100
#define B01100100 100
#define B1100101 101
#define B01100101 101
#define B1100110 102
#define B01100110 102
#define B1100111 103
#define B01100111 103
#define B1101000 104
#define B01101000 104
#define B1101001 105
#define B01101001 105
#define B1101010 106
#define B01101010 106
#define B1101011 107
#define B01101011 107
#define B1101100 108
#define B01101100 108
#define B1101101 109
#define B01101101 109
#define B1101110 110
#define B01101110 110
#define B1101111 111
#define B01101111 111
#define B1110000 112
#define B01110000 112
#define B1110001 113
#define B01110001 113
#define B1110010 114
#define B01110010 114
#define B1110011 115
#define B01110011 115
#define B1110100 116
#define B01110100 116
#define B1110101 117
#define B01110101 117
#define B1110110 118
#define B01110110 118
#define B1110111 119
#define B01110111 119
#define B1111000 120
#define B01111000 120
#define B1111001 121
#define B01111001 121
#define B1111010 122
#define B01111010 122
#define B1111011 123
#define B01111011 123
#define B1111100 124
#define B01111100 124
#define B1111101 125
#define B01111101 125
#define B1111110 126
#define B01111110 126
#define B1111111 127
#define B01111111 127
#define B10000000 128
#define B10000001 129
#define B10000010 130
#define B10000011 131
#define B10000100 132
#define B10000101 133
#define B10000110 134
#define B10000111 135
#define B10001000 136
#define B10001001 137
#define B10001010 138
#define B10001011 139
#define B10001100 140
#define B10001101 141
#define B10001110 142
#define B10001111 143
#define B10010000 144
#define B10010001 145
#define B10010010 146
#define B10010011 147
#define B10010100 148
#define B10010101 149
#define B10010110 150
#define B10010111 151
#define B10011000 152
#define B10011001 153
#define B10011010 154
#define B10011011 155
#define B10011100 156
#define B10011101 157
#define B10011110 158
#define B10011111 159
#define B10100000 160
#define B10100001 161
#define B10100010 162
#define B10100011 163
#define B10100100 164
#define B10100101 165
#define B10100110 166
#define B10100111 167
#define B10101000 168
#define B10101001 169
#define B10101010 170
#define B10101011 171
#define B10101100 172
#define B10101101 173
#define B10101110 174
#define B10101111 175
#define B10110000 176
#define B10110001 177
#define B10110010 178
#define B10110011 179
#define B10110100 180
#define B10110101 181
#define B10110110 182
#define B10110111 183
#define B10111000 184
#define B10111001 185
#define B10111010 186
#define B10111011 187
#define B10111100 188
#define B10111101 189
#define B10111110 190
#define B10111111 191
#define B11000000 192
#define B11000001 193
#define B11000010 194
#define B11000011 195
#define B11000100 196
#define B11000101 197
#define B11000110 198
#define B11000111 199
#define B11001000 200
#define B11001001 201
#define B11001010 202
#define B11001011 203
#define B11001100 204
#define B11001101 205
#define B11001110 206
#define B11001111 207
#define B11010000 208
#define B11010001 209
#define B11010010 210
#define B11010011 211
#define B11010100 212
#define B11010101 213
#define B11010110 214
#define B11010111 215
#define B11011000 216
#define B11011001 217
#define B11011010 218
#define B11011011 219
#define B11011100 220
#define B11011101 221
#define B11011110 222
#define B11011111 223
#define B11100000 224
#define B11100001 225
#define B11100010 226
#define B11100011 227
#define B11100100 228
#define B11100101 229
#define B11100110 230
#define B11100111 231
#define B11101000 232
#define B11101001 233
#define B11101010 234
#define B11101011 235
#define B11101100 236
#define B11101101 237
#define B11101110 238
#define B11101111 239
#define B11110000 240
#define B11110001 241
#define B11110010 242
#define B11110011 243
#define B11110100 244
#define B11110101 245
#define B11110110 246
#define B11110111 247
#define B11111000 248
#define B11111001 249
#define B11111010 250
#define B11111011 251
#define B11111100 252
#define B11111101 253
#define B11111110 254
#define B11111111 255
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/digitalWriteFast.h
================================================
/*
digitalWriteFast.h - A faster digitalWrite and digitalRead
...based partially on digitalWrite fast code by Paul Stoffregen,
as part of Teensyduino and partially based off of the earlier
arduino version http://code.google.com/p/digitalwritefast
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/* Only want to process this if pin count has been defined which inplies that the full variant.h has been read */
#ifdef PINS_COUNT
#ifndef _DIGITAL_WRITE_FAST_
#define _DIGITAL_WRITE_FAST_
#ifdef __cplusplus
extern "C" {
#endif
static inline void digitalWriteFast(uint8_t, uint8_t) __attribute__((always_inline, unused));
static inline void digitalWriteFast(uint8_t pin, uint8_t val)
{
if (__builtin_constant_p(pin)) {
if (val) {
if(pin < PINS_COUNT - 1) {
g_Pin2PortMapArray[pin].GPIOx_Port->BSRR = g_Pin2PortMapArray[pin].Pin_abstraction;
}
} else {
if (pin < PINS_COUNT - 1) {
g_Pin2PortMapArray[pin].GPIOx_Port->BSRR = (g_Pin2PortMapArray[pin].Pin_abstraction << 16);
}
}
} else {
digitalWrite(pin, val);
}
}
static inline int digitalReadFast(uint8_t) __attribute__((always_inline, unused));
static inline int digitalReadFast(uint8_t pin)
{
if (__builtin_constant_p(pin)) {
if (pin < PINS_COUNT - 1) {
return (g_Pin2PortMapArray[pin].GPIOx_Port->IDR & g_Pin2PortMapArray[pin].Pin_abstraction)? HIGH : LOW;
}
}
return digitalRead(pin);
}
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif /* _DIGITAL_WRITE_FAST_ */
#endif /* PINS_COUNT */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/itoa.c
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "itoa.h"
#include <string.h>
#ifdef __cplusplus
extern "C"{
#endif // __cplusplus
extern char* itoa( int value, char *string, int radix )
{
return ltoa( value, string, radix ) ;
}
extern char* ltoa( long value, char *string, int radix )
{
char tmp[33];
char *tp = tmp;
long i;
unsigned long v;
int sign;
char *sp;
if ( string == NULL )
{
return 0 ;
}
if (radix > 36 || radix <= 1)
{
return 0 ;
}
sign = (radix == 10 && value < 0);
if (sign)
{
v = -value;
}
else
{
v = (unsigned long)value;
}
while (v || tp == tmp)
{
i = v % radix;
v = v / radix;
if (i < 10)
*tp++ = i+'0';
else
*tp++ = i + 'a' - 10;
}
sp = string;
if (sign)
*sp++ = '-';
while (tp > tmp)
*sp++ = *--tp;
*sp = 0;
return string;
}
extern char* utoa( unsigned long value, char *string, int radix )
{
return ultoa( value, string, radix ) ;
}
extern char* ultoa( unsigned long value, char *string, int radix )
{
char tmp[33];
char *tp = tmp;
long i;
unsigned long v = value;
char *sp;
if ( string == NULL )
{
return 0;
}
if (radix > 36 || radix <= 1)
{
return 0;
}
while (v || tp == tmp)
{
i = v % radix;
v = v / radix;
if (i < 10)
*tp++ = i+'0';
else
*tp++ = i + 'a' - 10;
}
sp = string;
while (tp > tmp)
*sp++ = *--tp;
*sp = 0;
return string;
}
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/itoa.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _ITOA_
#define _ITOA_
#ifdef __cplusplus
extern "C"{
#endif // __cplusplus
#if 0
extern void itoa( int n, char s[] ) ;
#else
extern char* itoa( int value, char *string, int radix ) ;
extern char* ltoa( long value, char *string, int radix ) ;
//extern char* utoa( unsigned long value, char *string, int radix ) ;
extern char* ultoa( unsigned long value, char *string, int radix ) ;
#endif /* 0 */
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // _ITOA_
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/new.cpp
================================================
/*
Copyright (c) 2014 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
void *operator new(size_t size) {
return malloc(size);
}
void *operator new[](size_t size) {
return malloc(size);
}
void operator delete(void * ptr) {
free(ptr);
}
void operator delete[](void * ptr) {
free(ptr);
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/syscalls.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* \file syscalls.h
*
* Implementation of newlib syscall.
*
*/
/*----------------------------------------------------------------------------
* Headers
*----------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
/*----------------------------------------------------------------------------
* Exported functions
*----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
extern caddr_t _sbrk( int incr ) ;
extern int link( char *cOld, char *cNew ) ;
extern int _close( int file ) ;
extern int _fstat( int file, struct stat *st ) ;
extern int _isatty( int file ) ;
extern int _lseek( int file, int ptr, int dir ) ;
extern int _read(int file, char *ptr, int len) ;
extern int _write( int file, char *ptr, int len ) ;
#ifdef __cplusplus
}
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring.c
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "Arduino.h"
#include "drv_micros.h"
#ifdef __cplusplus
extern "C" {
#endif
/*
There is enough abstract similarity to Arduino that for some of these
we can just do the function with a define in the chip.h header
#define millis HAL_GetTick
#define delay HAL_Delay
*/
/*
Not sure how to do micros when the system clock ticks in milliseconds
*/
uint32_t micros( void )
{
return drv_micros();
}
#ifdef __cplusplus
}
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
Copyright (c) 2013 by Paul Stoffregen <paul@pjrc.com> (delayMicroseconds)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_
#define _WIRING_
#ifdef __cplusplus
extern "C" {
#endif
/**
*
*/
extern void initVariant( void ) ;
extern void init( void ) ;
/**
* \brief Returns the number of milliseconds since the Arduino board began running the current program.
*
* This number will overflow (go back to zero), after approximately 50 days.
*
* \return Number of milliseconds since the program started (uint32_t)
*/
extern uint32_t millis( void ) ;
/**
* \brief Returns the number of microseconds since the Arduino board began running the current program.
*
* This number will overflow (go back to zero), after approximately 70 minutes. On 16 MHz Arduino boards
* (e.g. Duemilanove and Nano), this function has a resolution of four microseconds (i.e. the value returned is
* always a multiple of four). On 8 MHz Arduino boards (e.g. the LilyPad), this function has a resolution
* of eight microseconds.
*
* \note There are 1,000 microseconds in a millisecond and 1,000,000 microseconds in a second.
*/
extern uint32_t micros( void ) ;
/**
* \brief Pauses the program for the amount of time (in miliseconds) specified as parameter.
* (There are 1000 milliseconds in a second.)
*
* \param dwMs the number of milliseconds to pause (uint32_t)
*/
extern void delay( uint32_t dwMs ) ;
/**
* \brief Pauses the program for the amount of time (in microseconds) specified as parameter.
*
* \param dwUs the number of microseconds to pause (uint32_t)
*/
static inline void delayMicroseconds(uint32_t) __attribute__((always_inline, unused));
static inline void delayMicroseconds(uint32_t usec){
uint32_t tTime;
tTime = micros();
while( (micros()-tTime) < usec );
}
#ifdef __cplusplus
}
#endif
#endif /* _WIRING_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_analog.c
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "Arduino.h"
#include "variant.h"
uint8_t analog_reference = DEFAULT;
static int _readResolution = 10;
static int _writeResolution = 8;
int readResolBackup = -1;
int writeResolBackup = -1;
void analogReadResolution(int res) {
_readResolution = res;
}
void analogWriteResolution(int res) {
_writeResolution = res;
}
static inline uint32_t mapResolution(uint32_t value, uint32_t from, uint32_t to) {
if (from == to)
return value;
if (from > to)
return value >> (from-to);
else
return value << (to-from);
}
void analogReference(uint8_t mode){
analog_reference = mode;
}
uint32_t analogRead( uint32_t ulPin ){
ADC_ChannelConfTypeDef sConfig;
ADC_HandleTypeDef *hADCx;
uint32_t ulValue = 0;
uint32_t ulChannel;
uint32_t adc_pin;
adc_pin = analogPinToChannel(ulPin);
ulChannel = g_Pin2PortMapArray[adc_pin].adc_channel;
if(ulChannel == NO_ADC)
return -1;
hADCx = g_Pin2PortMapArray[adc_pin].ADCx;
sConfig.Channel = ulChannel;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
HAL_ADC_ConfigChannel(hADCx, &sConfig);
HAL_ADC_Start(hADCx);
HAL_ADC_PollForConversion(hADCx, 10);
ulValue = HAL_ADC_GetValue(hADCx);
ulValue = mapResolution(ulValue, 12, _readResolution);
return ulValue;
}
void analogWrite( uint32_t ulPin, uint32_t ulValue ){
if( drv_pwm_get_init(ulPin) == false )
{
drv_pwm_setup(ulPin);
}
drv_pwm_set_duty(ulPin, _writeResolution, ulValue);
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_analog.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_ANALOG_
#define _WIRING_ANALOG_
//#include "stm32f1xx_hal.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_PWM_PIN 32
extern ADC_HandleTypeDef hadc1;
extern ADC_HandleTypeDef hadc2;
extern TIM_HandleTypeDef htim1;
extern TIM_HandleTypeDef htim2;
extern TIM_HandleTypeDef htim3;
extern TIM_HandleTypeDef htim4;
/*
* \brief SAM3 products have only one reference for ADC
*/
typedef enum _eAnalogReference
{
AR_DEFAULT,
} eAnalogReference ;
/*
* \brief Configures the reference voltage used for analog input (i.e. the value used as the top of the input range).
* This function is kept only for compatibility with existing AVR based API.
*
* \param ulMmode Should be set to AR_DEFAULT.
*/
extern void analogReference( eAnalogReference ulMode ) ;
/*
* \brief Writes an analog value (PWM wave) to a pin.
*
* \param ulPin
* \param ulValue
*/
extern void analogWrite( uint32_t ulPin, uint32_t ulValue ) ;
/*
* \brief Reads the value from the specified analog pin.
*
* \param ulPin
*
* \return Read value from selected pin, if no error.
*/
extern uint32_t analogRead( uint32_t ulPin ) ;
/*
* \brief Set the resolution of analogRead return values. Default is 10 bits (range from 0 to 1023).
*
* \param res
*/
extern void analogReadResolution(int res);
/*
* \brief Set the resolution of analogWrite parameters. Default is 8 bits (range from 0 to 255).
*
* \param res
*/
extern void analogWriteResolution(int res);
extern void analogOutputInit( void ) ;
extern void MX_TIMx_Init(uint32_t ulPin);
#ifdef __cplusplus
}
#endif
#endif /* _WIRING_ANALOG_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_constants.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_CONSTANTS_
#define _WIRING_CONSTANTS_
#ifdef __cplusplus
extern "C"{
#endif // __cplusplus
#define HIGH 0x1
#define LOW 0x0
#define INPUT 0x0
#define OUTPUT 0x1
#define INPUT_PULLUP 0x2
#define INPUT_ANALOG 0x3
#define INPUT_PULLDOWN 0x4
#define OUTPUT_OPEN 0x5
//#define true 0x1
//#define false 0x0
#define PI 3.1415926535897932384626433832795
#define HALF_PI 1.5707963267948966192313216916398
#define TWO_PI 6.283185307179586476925286766559
#define DEG_TO_RAD 0.017453292519943295769236907684886
#define RAD_TO_DEG 57.295779513082320876798154814105
#define EULER 2.718281828459045235360287471352
#define SERIAL 0x0
#define DISPLAY 0x1
enum BitOrder {
LSBFIRST = 0,
MSBFIRST = 1
};
// LOW 0
// HIGH 1
#define CHANGE 2
#define FALLING 3
#define RISING 4
#define DEFAULT 1
#define EXTERNAL 0
// undefine stdlib's abs if encountered
#ifdef abs
#undef abs
#endif // abs
#ifndef min
#define min(a,b) ((a)<(b)?(a):(b))
#endif // min
#ifndef max
#define max(a,b) ((a)>(b)?(a):(b))
#endif // max
#define abs(x) ((x)>0?(x):-(x))
#define constrain(amt,low,high) ((amt)<=(low)?(low):((amt)>=(high)?(high):(amt)))
//#define round(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5))
#define radians(deg) ((deg)*DEG_TO_RAD)
#define degrees(rad) ((rad)*RAD_TO_DEG)
#define sq(x) ((x)*(x))
#define interrupts() __enable_irq()
#define noInterrupts() __disable_irq()
#define lowByte(w) ((uint8_t) ((w) & 0xff))
#define highByte(w) ((uint8_t) ((w) >> 8))
#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
#define bitSet(value, bit) ((value) |= (1UL << (bit)))
#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
typedef unsigned int word;
#define bit(b) (1UL << (b))
typedef bool boolean ;
typedef uint8_t byte ;
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif /* _WIRING_CONSTANTS_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_digital.c
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "Arduino.h"
#include "variant.h"
#ifdef __cplusplus
extern "C" {
#endif
/*
the HAL drivers for STM32 do no access the registers directly
opaque structures are used to abstract the functions needed
existing STM examples show this defined locally a static
'static GPIO_InitTypeDef GPIO_InitStruct;'
value which we set here. This is different than the
way maple and sam set the pins as they use a global
array that contains device specific register setting values
GPIO_InitTypeDef has the following members defined in stm32f4xx_hal_gpio.h:
uint32_t Pin Specifies the GPIO pins to be configured.
typically a bitmapped mask that can be stored in a 16 bit value
uint32_t Mode Specifies the operating mode for the selected pins.
There are a number of modes that can be defined.
GPIO_MODE_INPUT Input Floating Mode
GPIO_MODE_OUTPUT_PP Output Push Pull Mode
GPIO_MODE_OUTPUT_OD Output Open Drain Mode
GPIO_MODE_AF_PP Alternate Function Push Pull Mode
GPIO_MODE_AF_OD Alternate Function Open Drain Mode
GPIO_MODE_ANALOG Analog Mode
GPIO_MODE_IT_RISING External Interrupt Mode with Rising edge trigger detection
GPIO_MODE_IT_FALLING External Interrupt Mode with Falling edge trigger detection
GPIO_MODE_IT_RISING_FALLING External Interrupt Mode with Rising/Falling edge trigger detection
GPIO_MODE_EVT_RISING External Event Mode with Rising edge trigger detection
GPIO_MODE_EVT_FALLING External Event Mode with Falling edge trigger detection
GPIO_MODE_EVT_RISING_FALLING External Event Mode with Rising/Falling edge trigger detection
uint32_t Pull Specifies the Pull-up or Pull-Down activation for the selected pins.
GPIO_NOPULL No Pull-up or Pull-down activation
GPIO_PULLUP Pull-up activation
GPIO_PULLDOWN Pull-down activation
uint32_t Speed Specifies the speed for the selected pins.
GPIO_SPEED_LOW Low speed
GPIO_SPEED_MEDIUM Medium speed
GPIO_SPEED_FAST Fast speed
GPIO_SPEED_HIGH High speed
uint32_t Alternate Peripheral to be connected to the selected pins.
these are defined in stm32f4xx_hal_gpio_ex.h
not all calls to HAL_GPIO_Init require this value to
be set in the existing example code
*/
extern void pinMode( uint32_t ulPin, uint32_t ulMode )
{
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = g_Pin2PortMapArray[ulPin].Pin_abstraction;
drv_pwm_release(ulPin);
switch ( ulMode )
{
case INPUT:
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
break ;
case INPUT_PULLUP:
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
break ;
case INPUT_PULLDOWN:
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
break;
case OUTPUT:
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
break ;
case OUTPUT_OPEN:
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
GPIO_InitStruct.Pull = GPIO_NOPULL;
break;
case INPUT_ANALOG:
drv_adc_pin_init(ulPin);
break;
default:
break ;
}
if( ulMode != INPUT_ANALOG )
{
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(g_Pin2PortMapArray[ulPin].GPIOx_Port, &GPIO_InitStruct);
}
}
extern void digitalWrite( uint32_t ulPin, uint32_t ulVal )
{
switch(ulVal) {
case HIGH:
/*
AVR allows for the writing of inputs to set the pull up state
we may want to do this here as well to maintain compatibility.
*/
HAL_GPIO_WritePin(g_Pin2PortMapArray[ulPin].GPIOx_Port,g_Pin2PortMapArray[ulPin].Pin_abstraction,GPIO_PIN_SET);
break;
case LOW:
/* simply reset the pin */
HAL_GPIO_WritePin(g_Pin2PortMapArray[ulPin].GPIOx_Port,g_Pin2PortMapArray[ulPin].Pin_abstraction,GPIO_PIN_RESET);
break;
default:
/* should do an assert here to handle error conditions */
break;
}
}
extern int digitalRead( uint32_t ulPin )
{
if(HAL_GPIO_ReadPin(g_Pin2PortMapArray[ulPin].GPIOx_Port,g_Pin2PortMapArray[ulPin].Pin_abstraction) == GPIO_PIN_RESET)
{
return LOW; // Set from HIGH to LOW by Vassilis Serasidis
}
return HIGH ; // Set from LOW to HIGH by Vassilis Serasidis
}
#ifdef __cplusplus
}
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_digital.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_DIGITAL_
#define _WIRING_DIGITAL_
#ifdef __cplusplus
extern "C" {
#endif
/**
* \brief Configures the specified pin to behave either as an input or an output. See the description of digital pins for details.
*
* \param ulPin The number of the pin whose mode you wish to set
* \param ulMode Either INPUT or OUTPUT
*/
extern void pinMode( uint32_t dwPin, uint32_t dwMode ) ;
/**
* \brief Write a HIGH or a LOW value to a digital pin.
*
* If the pin has been configured as an OUTPUT with pinMode(), its voltage will be set to the
* corresponding value: 5V (or 3.3V on 3.3V boards) for HIGH, 0V (ground) for LOW.
*
* If the pin is configured as an INPUT, writing a HIGH value with digitalWrite() will enable an internal
* 20K pullup resistor (see the tutorial on digital pins). Writing LOW will disable the pullup. The pullup
* resistor is enough to light an LED dimly, so if LEDs appear to work, but very dimly, this is a likely
* cause. The remedy is to set the pin to an output with the pinMode() function.
*
* \note Digital pin PIN_LED is harder to use as a digital input than the other digital pins because it has an LED
* and resistor attached to it that's soldered to the board on most boards. If you enable its internal 20k pull-up
* resistor, it will hang at around 1.7 V instead of the expected 5V because the onboard LED and series resistor
* pull the voltage level down, meaning it always returns LOW. If you must use pin PIN_LED as a digital input, use an
* external pull down resistor.
*
* \param dwPin the pin number
* \param dwVal HIGH or LOW
*/
extern void digitalWrite( uint32_t dwPin, uint32_t dwVal ) ;
/**
* \brief Reads the value from a specified digital pin, either HIGH or LOW.
*
* \param ulPin The number of the digital pin you want to read (int)
*
* \return HIGH or LOW
*/
extern int digitalRead( uint32_t ulPin ) ;
#ifdef __cplusplus
}
#endif
#endif /* _WIRING_DIGITAL_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_private.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef WiringPrivate_h
#define WiringPrivate_h
#include <stdint.h>
#include <stdio.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C"{
#endif
// Includes Atmel CMSIS
#include <chip.h>
#include "wiring_constants.h"
#ifdef __cplusplus
} // extern "C"
#include "HardwareSerial.h"
#endif
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_pulse.c
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "Arduino.h"
#include "variant.h"
/* Measures the length (in microseconds) of a pulse on the pin; state is HIGH
* or LOW, the type of pulse to measure. Works on pulses from 2-3 microseconds
* to 3 minutes in length, but must be called at least a few dozen microseconds
* before the start of the pulse.
*
* ATTENTION:
* this function relies on micros() so cannot be used in noInterrupt() context
*/
//This function is from pulseInLong func
uint32_t pulseIn( uint32_t ulPin, uint32_t state, uint32_t timeout )
{
// cache the port and bit of the pin in order to speed up the
// pulse width measuring loop and achieve finer resolution. calling
// digitalRead() instead yields much coarser resolution.
uint16_t bit = g_Pin2PortMapArray[ulPin].Pin_abstraction;
unsigned long stateMask = state ? bit : 0;
unsigned long startMicros = micros();
// wait for any previous pulse to end
while ((g_Pin2PortMapArray[ulPin].GPIOx_Port->IDR & bit) == stateMask)
if (micros() - startMicros > timeout)
return 0;
// wait for the pulse to start
while ((g_Pin2PortMapArray[ulPin].GPIOx_Port->IDR & bit) != stateMask)
if (micros() - startMicros > timeout)
return 0;
unsigned long start = micros();
// wait for the pulse to stop
while ((g_Pin2PortMapArray[ulPin].GPIOx_Port->IDR & bit) == stateMask){
if (micros() - startMicros > timeout)
return 0;
}
return micros() - start;
}
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_pulse.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_PULSE_
#define _WIRING_PULSE_
#ifdef __cplusplus
extern "C" {
#endif
/*
* \brief Measures the length (in microseconds) of a pulse on the pin; state is HIGH
* or LOW, the type of pulse to measure. Works on pulses from 2-3 microseconds
* to 3 minutes in length, but must be called at least a few dozen microseconds
* before the start of the pulse.
*/
extern uint32_t pulseIn( uint32_t ulPin, uint32_t ulState, uint32_t ulTimeout = 1000000L ) ;
#ifdef __cplusplus
}
#endif
#endif /* _WIRING_PULSE_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_shift.c
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "Arduino.h"
#ifdef __cplusplus
extern "C"{
#endif
uint32_t shiftIn( uint32_t ulDataPin, uint32_t ulClockPin, uint32_t ulBitOrder )
{
uint8_t value = 0 ;
uint8_t i ;
for ( i=0 ; i < 8 ; ++i )
{
digitalWrite( ulClockPin, HIGH ) ;
if ( ulBitOrder == LSBFIRST )
{
value |= digitalRead( ulDataPin ) << i ;
}
else
{
value |= digitalRead( ulDataPin ) << (7 - i) ;
}
digitalWrite( ulClockPin, LOW ) ;
}
return value ;
}
void shiftOut( uint32_t ulDataPin, uint32_t ulClockPin, uint32_t ulBitOrder, uint32_t ulVal )
{
uint8_t i ;
for ( i=0 ; i < 8 ; i++ )
{
if ( ulBitOrder == LSBFIRST )
{
digitalWrite( ulDataPin, !!(ulVal & (1 << i)) ) ;
}
else
{
digitalWrite( ulDataPin, !!(ulVal & (1 << (7 - i))) ) ;
}
digitalWrite( ulClockPin, HIGH ) ;
digitalWrite( ulClockPin, LOW ) ;
}
}
#ifdef __cplusplus
} // extern "C"
#endif
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_shift.h
================================================
/*
Copyright (c) 2011 Arduino. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _WIRING_SHIFT_
#define _WIRING_SHIFT_
#ifdef __cplusplus
extern "C" {
#endif
/*
* \brief
*/
extern uint32_t shiftIn( uint32_t ulDataPin, uint32_t ulClockPin, uint32_t ulBitOrder ) ;
/*
* \brief
*/
extern void shiftOut( uint32_t ulDataPin, uint32_t ulClockPin, uint32_t ulBitOrder, uint32_t ulVal ) ;
#ifdef __cplusplus
}
#endif
#endif /* _WIRING_SHIFT_ */
================================================
FILE: arduino/opencr_arduino/opencr/cores/arduino/yield.cpp
================================================
#include <Arduino.h>
void yield(void)
{
//TODO : code implementations
};
================================================
FILE: arduino/opencr_arduino/opencr/keywords.txt
================================================
# OpenCR specific functions
Serial4 KEYWORD1
printf KEYWORD2
flushRx KEYWORD2
getBaudRate KEYWORD2
getRxCnt KEYWORD2
getTxCnt KEYWORD2
# Arduino constants
# advanced pin states
OUTPUT_OPEN LITERAL1
INPUT_PULLDOWN LITERAL1
INPUT_ANALOG LITERAL1
================================================
FILE: arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_GFX.cpp
================================================
/*
This is the core graphics library for all our displays, providing a common
set of graphics primitives (points, lines, circles, etc.). It needs to be
paired with a hardware-specific library for each display device we carry
(to handle the lower-level functions).
Adafruit invests time and resources providing this open source code, please
support Adafruit & open-source hardware by purchasing products from Adafruit!
Copyright (c) 2013 Adafruit Industries. 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.
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 THE COPYRIGHT HOLDER OR CONTRIBUTORS 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.
*/
#include "Adafruit_GFX.h"
#include "glcdfont.c"
#ifdef __AVR__
#include <avr/pgmspace.h>
#elif defined(ESP8266) || defined(ESP32)
#include <pgmspace.h>
#endif
// Many (but maybe not all) non-AVR board installs define macros
// for compatibility with existing PROGMEM-reading AVR code.
// Do our own checks and defines here for good measure...
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
#ifndef pgm_read_word
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
#ifndef pgm_read_dword
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#endif
// Pointers are a peculiar case...typically 16-bit on AVR boards,
// 32 bits elsewhere. Try to accommodate both...
#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
#else
#define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef _swap_int16_t
#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
#endif
Adafruit_GFX::Adafruit_GFX(int16_t w, int16_t h):
WIDTH(w), HEIGHT(h)
{
_width = WIDTH;
_height = HEIGHT;
rotation = 0;
cursor_y = cursor_x = 0;
textsize = 1;
textcolor = textbgcolor = 0xFFFF;
wrap = true;
_cp437 = false;
gfxFont = NULL;
}
// Bresenham's algorithm - thx wikpedia
void Adafruit_GFX::writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t color) {
int16_t steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
_swap_int16_t(x0, y0);
_swap_int16_t(x1, y1);
}
if (x0 > x1) {
_swap_int16_t(x0, x1);
_swap_int16_t(y0, y1);
}
int16_t dx, dy;
dx = x1 - x0;
dy = abs(y1 - y0);
int16_t err = dx / 2;
int16_t ystep;
if (y0 < y1) {
ystep = 1;
} else {
ystep = -1;
}
for (; x0<=x1; x0++) {
if (steep) {
writePixel(y0, x0, color);
} else {
writePixel(x0, y0, color);
}
err -= dy;
if (err < 0) {
y0 += ystep;
err += dx;
}
}
}
void Adafruit_GFX::startWrite(){
// Overwrite in subclasses if desired!
}
void Adafruit_GFX::writePixel(int16_t x, int16_t y, uint16_t color){
// Overwrite in subclasses if startWrite is defined!
drawPixel(x, y, color);
}
// (x,y) is topmost point; if unsure, calling function
// should sort endpoints or call writeLine() instead
void Adafruit_GFX::writeFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color) {
// Overwrite in subclasses if startWrite is defined!
// Can be just writeLine(x, y, x, y+h-1, color);
// or writeFillRect(x, y, 1, h, color);
drawFastVLine(x, y, h, color);
}
// (x,y) is leftmost point; if unsure, calling function
// should sort endpoints or call writeLine() instead
void Adafruit_GFX::writeFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) {
// Overwrite in subclasses if startWrite is defined!
// Example: writeLine(x, y, x+w-1, y, color);
// or writeFillRect(x, y, w, 1, color);
drawFastHLine(x, y, w, color);
}
void Adafruit_GFX::writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
// Overwrite in subclasses if desired!
fillRect(x,y,w,h,color);
}
void Adafruit_GFX::endWrite(){
// Overwrite in subclasses if startWrite is defined!
}
// (x,y) is topmost point; if unsure, calling function
// should sort endpoints or call drawLine() instead
void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color) {
// Update in subclasses if desired!
startWrite();
writeLine(x, y, x, y+h-1, color);
endWrite();
}
// (x,y) is leftmost point; if unsure, calling function
// should sort endpoints or call drawLine() instead
void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) {
// Update in subclasses if desired!
startWrite();
writeLine(x, y, x+w-1, y, color);
endWrite();
}
void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
// Update in subclasses if desired!
startWrite();
for (int16_t i=x; i<x+w; i++) {
writeFastVLine(i, y, h, color);
}
endWrite();
}
void Adafruit_GFX::fillScreen(uint16_t color) {
// Update in subclasses if desired!
fillRect(0, 0, _width, _height, color);
}
void Adafruit_GFX::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t color) {
// Update in subclasses if desired!
if(x0 == x1){
if(y0 > y1) _swap_int16_t(y0, y1);
drawFastVLine(x0, y0, y1 - y0 + 1, color);
} else if(y0 == y1){
if(x0 > x1) _swap_int16_t(x0, x1);
drawFastHLine(x0, y0, x1 - x0 + 1, color);
} else {
startWrite();
writeLine(x0, y0, x1, y1, color);
endWrite();
}
}
// Draw a circle outline
void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
startWrite();
writePixel(x0 , y0+r, color);
writePixel(x0 , y0-r, color);
writePixel(x0+r, y0 , color);
writePixel(x0-r, y0 , color);
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
writePixel(x0 + x, y0 + y, color);
writePixel(x0 - x, y0 + y, color);
writePixel(x0 + x, y0 - y, color);
writePixel(x0 - x, y0 - y, color);
writePixel(x0 + y, y0 + x, color);
writePixel(x0 - y, y0 + x, color);
writePixel(x0 + y, y0 - x, color);
writePixel(x0 - y, y0 - x, color);
}
endWrite();
}
void Adafruit_GFX::drawCircleHelper( int16_t x0, int16_t y0,
int16_t r, uint8_t cornername, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x4) {
writePixel(x0 + x, y0 + y, color);
writePixel(x0 + y, y0 + x, color);
}
if (cornername & 0x2) {
writePixel(x0 + x, y0 - y, color);
writePixel(x0 + y, y0 - x, color);
}
if (cornername & 0x8) {
writePixel(x0 - y, y0 + x, color);
writePixel(x0 - x, y0 + y, color);
}
if (cornername & 0x1) {
writePixel(x0 - y, y0 - x, color);
writePixel(x0 - x, y0 - y, color);
}
}
}
void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
startWrite();
writeFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
endWrite();
}
// Used to do circles and roundrects
void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
uint8_t cornername, int16_t delta, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x1) {
writeFastVLine(x0+x, y0-y, 2*y+1+delta, color);
writeFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
writeFastVLine(x0-x, y0-y, 2*y+1+delta, color);
writeFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}
// Draw a rectangle
void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
startWrite();
writeFastHLine(x, y, w, color);
writeFastHLine(x, y+h-1, w, color);
writeFastVLine(x, y, h, color);
writeFastVLine(x+w-1, y, h, color);
endWrite();
}
// Draw a rounded rectangle
void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
startWrite();
writeFastHLine(x+r , y , w-2*r, color); // Top
writeFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
writeFastVLine(x , y+r , h-2*r, color); // Left
writeFastVLine(x+w-1, y+r , h-2*r, color); // Right
// draw four corners
drawCircleHelper(x+r , y+r , r, 1, color);
drawCircleHelper(x+w-r-1, y+r , r, 2, color);
drawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
drawCircleHelper(x+r , y+h-r-1, r, 8, color);
endWrite();
}
// Fill a rounded rectangle
void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
startWrite();
writeFillRect(x+r, y, w-2*r, h, color);
// draw four corners
fillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
fillCircleHelper(x+r , y+r, r, 2, h-2*r-1, color);
endWrite();
}
// Draw a triangle
void Adafruit_GFX::drawTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
drawLine(x0, y0, x1, y1, color);
drawLine(x1, y1, x2, y2, color);
drawLine(x2, y2, x0, y0, color);
}
// Fill a triangle
void Adafruit_GFX::fillTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
int16_t a, b, y, last;
// Sort coordinates by Y order (y2 >= y1 >= y0)
if (y0 > y1) {
_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
}
if (y1 > y2) {
_swap_int16_t(y2, y1); _swap_int16_t(x2, x1);
}
if (y0 > y1) {
_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
}
startWrite();
if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing
a = b = x0;
if(x1 < a) a = x1;
else if(x1 > b) b = x1;
if(x2 < a) a = x2;
else if(x2 > b) b = x2;
writeFastHLine(a, y0, b-a+1, color);
endWrite();
return;
}
int16_t
dx01 = x1 - x0,
dy01 = y1 - y0,
dx02 = x2 - x0,
dy02 = y2 - y0,
dx12 = x2 - x1,
dy12 = y2 - y1;
int32_t
sa = 0,
sb = 0;
// For upper part of triangle, find scanline crossings for segments
// 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
// is included here (and second loop will be skipped, avoiding a /0
// error there), otherwise scanline y1 is skipped here and handled
// in the second loop...which also avoids a /0 error here if y0=y1
// (flat-topped triangle).
if(y1 == y2) last = y1; // Include y1 scanline
else last = y1-1; // Skip it
for(y=y0; y<=last; y++) {
a = x0 + sa / dy01;
b = x0 + sb / dy02;
sa += dx01;
sb += dx02;
/* longhand:
a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) _swap_int16_t(a,b);
writeFastHLine(a, y, b-a+1, color);
}
// For lower part of triangle, find scanline crossings for segments
// 0-2 and 1-2. This loop is skipped if y1=y2.
sa = dx12 * (y - y1);
sb = dx02 * (y - y0);
for(; y<=y2; y++) {
a = x1 + sa / dy12;
b = x0 + sb / dy02;
sa += dx12;
sb += dx02;
/* longhand:
a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) _swap_int16_t(a,b);
writeFastHLine(a, y, b-a+1, color);
}
endWrite();
}
// BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS ---------------------
// Draw a PROGMEM-resident 1-bit image at the specified (x,y) position,
// using the specified foreground color (unset bits are transparent).
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++) {
if(i & 7) byte <<= 1;
else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
if(byte & 0x80) writePixel(x+i, y, color);
}
}
endWrite();
}
// Draw a PROGMEM-resident 1-bit image at the specified (x,y) position,
// using the specified foreground (for set bits) and background (unset
// bits) colors.
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h,
uint16_t color, uint16_t bg) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
writePixel(x+i, y, (byte & 0x80) ? color : bg);
}
}
endWrite();
}
// Draw a RAM-resident 1-bit image at the specified (x,y) position,
// using the specified foreground color (unset bits are transparent).
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = bitmap[j * byteWidth + i / 8];
if(byte & 0x80) writePixel(x+i, y, color);
}
}
endWrite();
}
// Draw a RAM-resident 1-bit image at the specified (x,y) position,
// using the specified foreground (for set bits) and background (unset
// bits) colors.
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = bitmap[j * byteWidth + i / 8];
writePixel(x+i, y, (byte & 0x80) ? color : bg);
}
}
endWrite();
}
// Draw PROGMEM-resident XBitMap Files (*.xbm), exported from GIMP,
// Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
// C Array can be directly used with this function.
// There is no RAM-resident version of this function; if generating bitmaps
// in RAM, use the format defined by drawBitmap() and call that instead.
void Adafruit_GFX::drawXBitmap(int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte >>= 1;
else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
// Nearly identical to drawBitmap(), only the bit order
// is reversed here (left-to-right = LSB to MSB):
if(byte & 0x01) writePixel(x+i, y, color);
}
}
endWrite();
}
// Draw a PROGMEM-resident 8-bit image (grayscale) at the specified (x,y)
// pos. Specifically for 8-bit display devices such as IS31FL3731;
// no color reduction/expansion is performed.
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h) {
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
writePixel(x+i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i]));
}
}
endWrite();
}
// Draw a RAM-resident 8-bit image (grayscale) at the specified (x,y)
// pos. Specifically for 8-bit display devices such as I
gitextract_31yzf8ck/ ├── .github/ │ └── workflows/ │ └── arduino_ci.yml ├── .gitignore ├── .project ├── 49-stlinkv2.rules ├── 99-opencr-cdc.rules ├── LICENSE ├── README.md ├── arduino/ │ ├── opencr_arduino/ │ │ ├── opencr/ │ │ │ ├── .gitignore │ │ │ ├── boards.txt │ │ │ ├── cores/ │ │ │ │ └── arduino/ │ │ │ │ ├── Arduino.h │ │ │ │ ├── Client.h │ │ │ │ ├── HardwareSerial.h │ │ │ │ ├── HardwareTimer.cpp │ │ │ │ ├── HardwareTimer.h │ │ │ │ ├── IPAddress.cpp │ │ │ │ ├── IPAddress.h │ │ │ │ ├── Print.cpp │ │ │ │ ├── Print.h │ │ │ │ ├── Printable.h │ │ │ │ ├── Reset.h │ │ │ │ ├── RingBuffer.cpp │ │ │ │ ├── RingBuffer.h │ │ │ │ ├── Server.h │ │ │ │ ├── Stream.cpp │ │ │ │ ├── Stream.h │ │ │ │ ├── Tone.cpp │ │ │ │ ├── Tone.h │ │ │ │ ├── UARTClass.cpp │ │ │ │ ├── UARTClass.h │ │ │ │ ├── USBSerial.cpp │ │ │ │ ├── USBSerial.h │ │ │ │ ├── Udp.h │ │ │ │ ├── WCharacter.h │ │ │ │ ├── WInterrupts.c │ │ │ │ ├── WInterrupts.h │ │ │ │ ├── WMath.cpp │ │ │ │ ├── WMath.h │ │ │ │ ├── WString.cpp │ │ │ │ ├── WString.h │ │ │ │ ├── avr/ │ │ │ │ │ ├── dtostrf.c │ │ │ │ │ ├── dtostrf.h │ │ │ │ │ ├── interrupt.h │ │ │ │ │ └── pgmspace.h │ │ │ │ ├── binary.h │ │ │ │ ├── digitalWriteFast.h │ │ │ │ ├── itoa.c │ │ │ │ ├── itoa.h │ │ │ │ ├── new.cpp │ │ │ │ ├── syscalls.h │ │ │ │ ├── wiring.c │ │ │ │ ├── wiring.h │ │ │ │ ├── wiring_analog.c │ │ │ │ ├── wiring_analog.h │ │ │ │ ├── wiring_constants.h │ │ │ │ ├── wiring_digital.c │ │ │ │ ├── wiring_digital.h │ │ │ │ ├── wiring_private.h │ │ │ │ ├── wiring_pulse.c │ │ │ │ ├── wiring_pulse.h │ │ │ │ ├── wiring_shift.c │ │ │ │ ├── wiring_shift.h │ │ │ │ └── yield.cpp │ │ │ ├── keywords.txt │ │ │ ├── libraries/ │ │ │ │ ├── Adafruit_GFX_Library/ │ │ │ │ │ ├── Adafruit_GFX.cpp │ │ │ │ │ ├── Adafruit_GFX.h │ │ │ │ │ ├── Adafruit_SPITFT.cpp │ │ │ │ │ ├── Adafruit_SPITFT.h │ │ │ │ │ ├── Adafruit_SPITFT_Macros.h │ │ │ │ │ ├── Fonts/ │ │ │ │ │ │ ├── FreeMono12pt7b.h │ │ │ │ │ │ ├── FreeMono18pt7b.h │ │ │ │ │ │ ├── FreeMono24pt7b.h │ │ │ │ │ │ ├── FreeMono9pt7b.h │ │ │ │ │ │ ├── FreeMonoBold12pt7b.h │ │ │ │ │ │ ├── FreeMonoBold18pt7b.h │ │ │ │ │ │ ├── FreeMonoBold24pt7b.h │ │ │ │ │ │ ├── FreeMonoBold9pt7b.h │ │ │ │ │ │ ├── FreeMonoBoldOblique12pt7b.h │ │ │ │ │ │ ├── FreeMonoBoldOblique18pt7b.h │ │ │ │ │ │ ├── FreeMonoBoldOblique24pt7b.h │ │ │ │ │ │ ├── FreeMonoBoldOblique9pt7b.h │ │ │ │ │ │ ├── FreeMonoOblique12pt7b.h │ │ │ │ │ │ ├── FreeMonoOblique18pt7b.h │ │ │ │ │ │ ├── FreeMonoOblique24pt7b.h │ │ │ │ │ │ ├── FreeMonoOblique9pt7b.h │ │ │ │ │ │ ├── FreeSans12pt7b.h │ │ │ │ │ │ ├── FreeSans18pt7b.h │ │ │ │ │ │ ├── FreeSans24pt7b.h │ │ │ │ │ │ ├── FreeSans9pt7b.h │ │ │ │ │ │ ├── FreeSansBold12pt7b.h │ │ │ │ │ │ ├── FreeSansBold18pt7b.h │ │ │ │ │ │ ├── FreeSansBold24pt7b.h │ │ │ │ │ │ ├── FreeSansBold9pt7b.h │ │ │ │ │ │ ├── FreeSansBoldOblique12pt7b.h │ │ │ │ │ │ ├── FreeSansBoldOblique18pt7b.h │ │ │ │ │ │ ├── FreeSansBoldOblique24pt7b.h │ │ │ │ │ │ ├── FreeSansBoldOblique9pt7b.h │ │ │ │ │ │ ├── FreeSansOblique12pt7b.h │ │ │ │ │ │ ├── FreeSansOblique18pt7b.h │ │ │ │ │ │ ├── FreeSansOblique24pt7b.h │ │ │ │ │ │ ├── FreeSansOblique9pt7b.h │ │ │ │ │ │ ├── FreeSerif12pt7b.h │ │ │ │ │ │ ├── FreeSerif18pt7b.h │ │ │ │ │ │ ├── FreeSerif24pt7b.h │ │ │ │ │ │ ├── FreeSerif9pt7b.h │ │ │ │ │ │ ├── FreeSerifBold12pt7b.h │ │ │ │ │ │ ├── FreeSerifBold18pt7b.h │ │ │ │ │ │ ├── FreeSerifBold24pt7b.h │ │ │ │ │ │ ├── FreeSerifBold9pt7b.h │ │ │ │ │ │ ├── FreeSerifBoldItalic12pt7b.h │ │ │ │ │ │ ├── FreeSerifBoldItalic18pt7b.h │ │ │ │ │ │ ├── FreeSerifBoldItalic24pt7b.h │ │ │ │ │ │ ├── FreeSerifBoldItalic9pt7b.h │ │ │ │ │ │ ├── FreeSerifItalic12pt7b.h │ │ │ │ │ │ ├── FreeSerifItalic18pt7b.h │ │ │ │ │ │ ├── FreeSerifItalic24pt7b.h │ │ │ │ │ │ ├── FreeSerifItalic9pt7b.h │ │ │ │ │ │ ├── Org_01.h │ │ │ │ │ │ ├── Picopixel.h │ │ │ │ │ │ ├── Tiny3x3a2pt7b │ │ │ │ │ │ └── TomThumb.h │ │ │ │ │ ├── README.md │ │ │ │ │ ├── fontconvert/ │ │ │ │ │ │ ├── Makefile │ │ │ │ │ │ ├── fontconvert.c │ │ │ │ │ │ ├── fontconvert_win.md │ │ │ │ │ │ └── makefonts.sh │ │ │ │ │ ├── gfxfont.h │ │ │ │ │ ├── glcdfont.c │ │ │ │ │ ├── library.properties │ │ │ │ │ └── license.txt │ │ │ │ ├── CAN/ │ │ │ │ │ ├── CAN.cpp │ │ │ │ │ └── CAN.h │ │ │ │ ├── DynamixelSDK/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── include/ │ │ │ │ │ │ └── dynamixel_sdk/ │ │ │ │ │ │ ├── dynamixel_sdk.h │ │ │ │ │ │ ├── group_bulk_read.h │ │ │ │ │ │ ├── group_bulk_write.h │ │ │ │ │ │ ├── group_sync_read.h │ │ │ │ │ │ ├── group_sync_write.h │ │ │ │ │ │ ├── packet_handler.h │ │ │ │ │ │ ├── port_handler.h │ │ │ │ │ │ ├── port_handler_arduino.h │ │ │ │ │ │ ├── port_handler_linux.h │ │ │ │ │ │ ├── port_handler_mac.h │ │ │ │ │ │ ├── port_handler_windows.h │ │ │ │ │ │ ├── protocol1_packet_handler.h │ │ │ │ │ │ └── protocol2_packet_handler.h │ │ │ │ │ ├── keywords.txt │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── DynamixelSDK.h │ │ │ │ │ └── dynamixel_sdk/ │ │ │ │ │ ├── group_bulk_read.cpp │ │ │ │ │ ├── group_bulk_write.cpp │ │ │ │ │ ├── group_sync_read.cpp │ │ │ │ │ ├── group_sync_write.cpp │ │ │ │ │ ├── packet_handler.cpp │ │ │ │ │ ├── port_handler.cpp │ │ │ │ │ ├── port_handler_arduino.cpp │ │ │ │ │ ├── port_handler_linux.cpp │ │ │ │ │ ├── port_handler_mac.cpp │ │ │ │ │ ├── port_handler_windows.cpp │ │ │ │ │ ├── protocol1_packet_handler.cpp │ │ │ │ │ └── protocol2_packet_handler.cpp │ │ │ │ ├── DynamixelWorkbench/ │ │ │ │ │ ├── include/ │ │ │ │ │ │ └── dynamixel_workbench_toolbox/ │ │ │ │ │ │ ├── dynamixel_driver.h │ │ │ │ │ │ ├── dynamixel_item.h │ │ │ │ │ │ ├── dynamixel_tool.h │ │ │ │ │ │ └── dynamixel_workbench.h │ │ │ │ │ ├── keywords.txt │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── DynamixelWorkbench.h │ │ │ │ │ └── dynamixel_workbench_toolbox/ │ │ │ │ │ ├── dynamixel_driver.cpp │ │ │ │ │ ├── dynamixel_item.cpp │ │ │ │ │ ├── dynamixel_tool.cpp │ │ │ │ │ └── dynamixel_workbench.cpp │ │ │ │ ├── EEPROM/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── keywords.txt │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ └── EEPROM.h │ │ │ │ ├── Eigen331/ │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── Eigen/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── Cholesky │ │ │ │ │ │ ├── CholmodSupport │ │ │ │ │ │ ├── Core │ │ │ │ │ │ ├── Dense │ │ │ │ │ │ ├── Eigen │ │ │ │ │ │ ├── Eigenvalues │ │ │ │ │ │ ├── Geometry │ │ │ │ │ │ ├── Householder │ │ │ │ │ │ ├── IterativeLinearSolvers │ │ │ │ │ │ ├── Jacobi │ │ │ │ │ │ ├── LU │ │ │ │ │ │ ├── MetisSupport │ │ │ │ │ │ ├── OrderingMethods │ │ │ │ │ │ ├── PaStiXSupport │ │ │ │ │ │ ├── PardisoSupport │ │ │ │ │ │ ├── QR │ │ │ │ │ │ ├── QtAlignedMalloc │ │ │ │ │ │ ├── SPQRSupport │ │ │ │ │ │ ├── SVD │ │ │ │ │ │ ├── Sparse │ │ │ │ │ │ ├── SparseCholesky │ │ │ │ │ │ ├── SparseCore │ │ │ │ │ │ ├── SparseLU │ │ │ │ │ │ ├── SparseQR │ │ │ │ │ │ ├── StdDeque │ │ │ │ │ │ ├── StdList │ │ │ │ │ │ ├── StdVector │ │ │ │ │ │ ├── SuperLUSupport │ │ │ │ │ │ ├── UmfPackSupport │ │ │ │ │ │ └── src/ │ │ │ │ │ │ ├── Cholesky/ │ │ │ │ │ │ │ ├── LDLT.h │ │ │ │ │ │ │ ├── LLT.h │ │ │ │ │ │ │ └── LLT_LAPACKE.h │ │ │ │ │ │ ├── CholmodSupport/ │ │ │ │ │ │ │ └── CholmodSupport.h │ │ │ │ │ │ ├── Core/ │ │ │ │ │ │ │ ├── Array.h │ │ │ │ │ │ │ ├── ArrayBase.h │ │ │ │ │ │ │ ├── ArrayWrapper.h │ │ │ │ │ │ │ ├── Assign.h │ │ │ │ │ │ │ ├── AssignEvaluator.h │ │ │ │ │ │ │ ├── Assign_MKL.h │ │ │ │ │ │ │ ├── BandMatrix.h │ │ │ │ │ │ │ ├── Block.h │ │ │ │ │ │ │ ├── BooleanRedux.h │ │ │ │ │ │ │ ├── CommaInitializer.h │ │ │ │ │ │ │ ├── ConditionEstimator.h │ │ │ │ │ │ │ ├── CoreEvaluators.h │ │ │ │ │ │ │ ├── CoreIterators.h │ │ │ │ │ │ │ ├── CwiseBinaryOp.h │ │ │ │ │ │ │ ├── CwiseNullaryOp.h │ │ │ │ │ │ │ ├── CwiseTernaryOp.h │ │ │ │ │ │ │ ├── CwiseUnaryOp.h │ │ │ │ │ │ │ ├── CwiseUnaryView.h │ │ │ │ │ │ │ ├── DenseBase.h │ │ │ │ │ │ │ ├── DenseCoeffsBase.h │ │ │ │ │ │ │ ├── DenseStorage.h │ │ │ │ │ │ │ ├── Diagonal.h │ │ │ │ │ │ │ ├── DiagonalMatrix.h │ │ │ │ │ │ │ ├── DiagonalProduct.h │ │ │ │ │ │ │ ├── Dot.h │ │ │ │ │ │ │ ├── EigenBase.h │ │ │ │ │ │ │ ├── ForceAlignedAccess.h │ │ │ │ │ │ │ ├── Fuzzy.h │ │ │ │ │ │ │ ├── GeneralProduct.h │ │ │ │ │ │ │ ├── GenericPacketMath.h │ │ │ │ │ │ │ ├── GlobalFunctions.h │ │ │ │ │ │ │ ├── IO.h │ │ │ │ │ │ │ ├── Inverse.h │ │ │ │ │ │ │ ├── Map.h │ │ │ │ │ │ │ ├── MapBase.h │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ ├── MathFunctionsImpl.h │ │ │ │ │ │ │ ├── Matrix.h │ │ │ │ │ │ │ ├── MatrixBase.h │ │ │ │ │ │ │ ├── NestByValue.h │ │ │ │ │ │ │ ├── NoAlias.h │ │ │ │ │ │ │ ├── NumTraits.h │ │ │ │ │ │ │ ├── PermutationMatrix.h │ │ │ │ │ │ │ ├── PlainObjectBase.h │ │ │ │ │ │ │ ├── Product.h │ │ │ │ │ │ │ ├── ProductEvaluators.h │ │ │ │ │ │ │ ├── Random.h │ │ │ │ │ │ │ ├── Redux.h │ │ │ │ │ │ │ ├── Ref.h │ │ │ │ │ │ │ ├── Replicate.h │ │ │ │ │ │ │ ├── ReturnByValue.h │ │ │ │ │ │ │ ├── Reverse.h │ │ │ │ │ │ │ ├── Select.h │ │ │ │ │ │ │ ├── SelfAdjointView.h │ │ │ │ │ │ │ ├── SelfCwiseBinaryOp.h │ │ │ │ │ │ │ ├── Solve.h │ │ │ │ │ │ │ ├── SolveTriangular.h │ │ │ │ │ │ │ ├── SolverBase.h │ │ │ │ │ │ │ ├── StableNorm.h │ │ │ │ │ │ │ ├── Stride.h │ │ │ │ │ │ │ ├── Swap.h │ │ │ │ │ │ │ ├── Transpose.h │ │ │ │ │ │ │ ├── Transpositions.h │ │ │ │ │ │ │ ├── TriangularMatrix.h │ │ │ │ │ │ │ ├── VectorBlock.h │ │ │ │ │ │ │ ├── VectorwiseOp.h │ │ │ │ │ │ │ ├── Visitor.h │ │ │ │ │ │ │ ├── arch/ │ │ │ │ │ │ │ │ ├── AVX/ │ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ │ │ │ │ └── TypeCasting.h │ │ │ │ │ │ │ │ ├── AVX512/ │ │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ │ └── PacketMath.h │ │ │ │ │ │ │ │ ├── AltiVec/ │ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ │ └── PacketMath.h │ │ │ │ │ │ │ │ ├── CUDA/ │ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ │ ├── Half.h │ │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ │ │ │ │ ├── PacketMathHalf.h │ │ │ │ │ │ │ │ │ └── TypeCasting.h │ │ │ │ │ │ │ │ ├── Default/ │ │ │ │ │ │ │ │ │ └── Settings.h │ │ │ │ │ │ │ │ ├── NEON/ │ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ │ └── PacketMath.h │ │ │ │ │ │ │ │ ├── SSE/ │ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ │ │ │ │ └── TypeCasting.h │ │ │ │ │ │ │ │ └── ZVector/ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ └── PacketMath.h │ │ │ │ │ │ │ ├── functors/ │ │ │ │ │ │ │ │ ├── AssignmentFunctors.h │ │ │ │ │ │ │ │ ├── BinaryFunctors.h │ │ │ │ │ │ │ │ ├── NullaryFunctors.h │ │ │ │ │ │ │ │ ├── StlFunctors.h │ │ │ │ │ │ │ │ ├── TernaryFunctors.h │ │ │ │ │ │ │ │ └── UnaryFunctors.h │ │ │ │ │ │ │ ├── products/ │ │ │ │ │ │ │ │ ├── GeneralBlockPanelKernel.h │ │ │ │ │ │ │ │ ├── GeneralMatrixMatrix.h │ │ │ │ │ │ │ │ ├── GeneralMatrixMatrixTriangular.h │ │ │ │ │ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h │ │ │ │ │ │ │ │ ├── GeneralMatrixMatrix_BLAS.h │ │ │ │ │ │ │ │ ├── GeneralMatrixVector.h │ │ │ │ │ │ │ │ ├── GeneralMatrixVector_BLAS.h │ │ │ │ │ │ │ │ ├── Parallelizer.h │ │ │ │ │ │ │ │ ├── SelfadjointMatrixMatrix.h │ │ │ │ │ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h │ │ │ │ │ │ │ │ ├── SelfadjointMatrixVector.h │ │ │ │ │ │ │ │ ├── SelfadjointMatrixVector_BLAS.h │ │ │ │ │ │ │ │ ├── SelfadjointProduct.h │ │ │ │ │ │ │ │ ├── SelfadjointRank2Update.h │ │ │ │ │ │ │ │ ├── TriangularMatrixMatrix.h │ │ │ │ │ │ │ │ ├── TriangularMatrixMatrix_BLAS.h │ │ │ │ │ │ │ │ ├── TriangularMatrixVector.h │ │ │ │ │ │ │ │ ├── TriangularMatrixVector_BLAS.h │ │ │ │ │ │ │ │ ├── TriangularSolverMatrix.h │ │ │ │ │ │ │ │ ├── TriangularSolverMatrix_BLAS.h │ │ │ │ │ │ │ │ └── TriangularSolverVector.h │ │ │ │ │ │ │ └── util/ │ │ │ │ │ │ │ ├── BlasUtil.h │ │ │ │ │ │ │ ├── Constants.h │ │ │ │ │ │ │ ├── DisableStupidWarnings.h │ │ │ │ │ │ │ ├── ForwardDeclarations.h │ │ │ │ │ │ │ ├── MKL_support.h │ │ │ │ │ │ │ ├── Macros.h │ │ │ │ │ │ │ ├── Memory.h │ │ │ │ │ │ │ ├── Meta.h │ │ │ │ │ │ │ ├── NonMPL2.h │ │ │ │ │ │ │ ├── ReenableStupidWarnings.h │ │ │ │ │ │ │ ├── StaticAssert.h │ │ │ │ │ │ │ └── XprHelper.h │ │ │ │ │ │ ├── Eigenvalues/ │ │ │ │ │ │ │ ├── ComplexEigenSolver.h │ │ │ │ │ │ │ ├── ComplexSchur.h │ │ │ │ │ │ │ ├── ComplexSchur_LAPACKE.h │ │ │ │ │ │ │ ├── EigenSolver.h │ │ │ │ │ │ │ ├── GeneralizedEigenSolver.h │ │ │ │ │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h │ │ │ │ │ │ │ ├── HessenbergDecomposition.h │ │ │ │ │ │ │ ├── MatrixBaseEigenvalues.h │ │ │ │ │ │ │ ├── RealQZ.h │ │ │ │ │ │ │ ├── RealSchur.h │ │ │ │ │ │ │ ├── RealSchur_LAPACKE.h │ │ │ │ │ │ │ ├── SelfAdjointEigenSolver.h │ │ │ │ │ │ │ ├── SelfAdjointEigenSolver_LAPACKE.h │ │ │ │ │ │ │ └── Tridiagonalization.h │ │ │ │ │ │ ├── Geometry/ │ │ │ │ │ │ │ ├── AlignedBox.h │ │ │ │ │ │ │ ├── AngleAxis.h │ │ │ │ │ │ │ ├── EulerAngles.h │ │ │ │ │ │ │ ├── Homogeneous.h │ │ │ │ │ │ │ ├── Hyperplane.h │ │ │ │ │ │ │ ├── OrthoMethods.h │ │ │ │ │ │ │ ├── ParametrizedLine.h │ │ │ │ │ │ │ ├── Quaternion.h │ │ │ │ │ │ │ ├── Rotation2D.h │ │ │ │ │ │ │ ├── RotationBase.h │ │ │ │ │ │ │ ├── Scaling.h │ │ │ │ │ │ │ ├── Transform.h │ │ │ │ │ │ │ ├── Translation.h │ │ │ │ │ │ │ ├── Umeyama.h │ │ │ │ │ │ │ └── arch/ │ │ │ │ │ │ │ └── Geometry_SSE.h │ │ │ │ │ │ ├── Householder/ │ │ │ │ │ │ │ ├── BlockHouseholder.h │ │ │ │ │ │ │ ├── Householder.h │ │ │ │ │ │ │ └── HouseholderSequence.h │ │ │ │ │ │ ├── IterativeLinearSolvers/ │ │ │ │ │ │ │ ├── BasicPreconditioners.h │ │ │ │ │ │ │ ├── BiCGSTAB.h │ │ │ │ │ │ │ ├── ConjugateGradient.h │ │ │ │ │ │ │ ├── IncompleteCholesky.h │ │ │ │ │ │ │ ├── IncompleteLUT.h │ │ │ │ │ │ │ ├── IterativeSolverBase.h │ │ │ │ │ │ │ ├── LeastSquareConjugateGradient.h │ │ │ │ │ │ │ └── SolveWithGuess.h │ │ │ │ │ │ ├── Jacobi/ │ │ │ │ │ │ │ └── Jacobi.h │ │ │ │ │ │ ├── LU/ │ │ │ │ │ │ │ ├── Determinant.h │ │ │ │ │ │ │ ├── FullPivLU.h │ │ │ │ │ │ │ ├── InverseImpl.h │ │ │ │ │ │ │ ├── PartialPivLU.h │ │ │ │ │ │ │ ├── PartialPivLU_LAPACKE.h │ │ │ │ │ │ │ └── arch/ │ │ │ │ │ │ │ └── Inverse_SSE.h │ │ │ │ │ │ ├── MetisSupport/ │ │ │ │ │ │ │ └── MetisSupport.h │ │ │ │ │ │ ├── OrderingMethods/ │ │ │ │ │ │ │ ├── Amd.h │ │ │ │ │ │ │ ├── Eigen_Colamd.h │ │ │ │ │ │ │ └── Ordering.h │ │ │ │ │ │ ├── PaStiXSupport/ │ │ │ │ │ │ │ └── PaStiXSupport.h │ │ │ │ │ │ ├── PardisoSupport/ │ │ │ │ │ │ │ └── PardisoSupport.h │ │ │ │ │ │ ├── QR/ │ │ │ │ │ │ │ ├── ColPivHouseholderQR.h │ │ │ │ │ │ │ ├── ColPivHouseholderQR_LAPACKE.h │ │ │ │ │ │ │ ├── CompleteOrthogonalDecomposition.h │ │ │ │ │ │ │ ├── FullPivHouseholderQR.h │ │ │ │ │ │ │ ├── HouseholderQR.h │ │ │ │ │ │ │ └── HouseholderQR_LAPACKE.h │ │ │ │ │ │ ├── SPQRSupport/ │ │ │ │ │ │ │ └── SuiteSparseQRSupport.h │ │ │ │ │ │ ├── SVD/ │ │ │ │ │ │ │ ├── BDCSVD.h │ │ │ │ │ │ │ ├── JacobiSVD.h │ │ │ │ │ │ │ ├── JacobiSVD_LAPACKE.h │ │ │ │ │ │ │ ├── SVDBase.h │ │ │ │ │ │ │ └── UpperBidiagonalization.h │ │ │ │ │ │ ├── SparseCholesky/ │ │ │ │ │ │ │ ├── SimplicialCholesky.h │ │ │ │ │ │ │ └── SimplicialCholesky_impl.h │ │ │ │ │ │ ├── SparseCore/ │ │ │ │ │ │ │ ├── AmbiVector.h │ │ │ │ │ │ │ ├── CompressedStorage.h │ │ │ │ │ │ │ ├── ConservativeSparseSparseProduct.h │ │ │ │ │ │ │ ├── MappedSparseMatrix.h │ │ │ │ │ │ │ ├── SparseAssign.h │ │ │ │ │ │ │ ├── SparseBlock.h │ │ │ │ │ │ │ ├── SparseColEtree.h │ │ │ │ │ │ │ ├── SparseCompressedBase.h │ │ │ │ │ │ │ ├── SparseCwiseBinaryOp.h │ │ │ │ │ │ │ ├── SparseCwiseUnaryOp.h │ │ │ │ │ │ │ ├── SparseDenseProduct.h │ │ │ │ │ │ │ ├── SparseDiagonalProduct.h │ │ │ │ │ │ │ ├── SparseDot.h │ │ │ │ │ │ │ ├── SparseFuzzy.h │ │ │ │ │ │ │ ├── SparseMap.h │ │ │ │ │ │ │ ├── SparseMatrix.h │ │ │ │ │ │ │ ├── SparseMatrixBase.h │ │ │ │ │ │ │ ├── SparsePermutation.h │ │ │ │ │ │ │ ├── SparseProduct.h │ │ │ │ │ │ │ ├── SparseRedux.h │ │ │ │ │ │ │ ├── SparseRef.h │ │ │ │ │ │ │ ├── SparseSelfAdjointView.h │ │ │ │ │ │ │ ├── SparseSolverBase.h │ │ │ │ │ │ │ ├── SparseSparseProductWithPruning.h │ │ │ │ │ │ │ ├── SparseTranspose.h │ │ │ │ │ │ │ ├── SparseTriangularView.h │ │ │ │ │ │ │ ├── SparseUtil.h │ │ │ │ │ │ │ ├── SparseVector.h │ │ │ │ │ │ │ ├── SparseView.h │ │ │ │ │ │ │ └── TriangularSolver.h │ │ │ │ │ │ ├── SparseLU/ │ │ │ │ │ │ │ ├── SparseLU.h │ │ │ │ │ │ │ ├── SparseLUImpl.h │ │ │ │ │ │ │ ├── SparseLU_Memory.h │ │ │ │ │ │ │ ├── SparseLU_Structs.h │ │ │ │ │ │ │ ├── SparseLU_SupernodalMatrix.h │ │ │ │ │ │ │ ├── SparseLU_Utils.h │ │ │ │ │ │ │ ├── SparseLU_column_bmod.h │ │ │ │ │ │ │ ├── SparseLU_column_dfs.h │ │ │ │ │ │ │ ├── SparseLU_copy_to_ucol.h │ │ │ │ │ │ │ ├── SparseLU_gemm_kernel.h │ │ │ │ │ │ │ ├── SparseLU_heap_relax_snode.h │ │ │ │ │ │ │ ├── SparseLU_kernel_bmod.h │ │ │ │ │ │ │ ├── SparseLU_panel_bmod.h │ │ │ │ │ │ │ ├── SparseLU_panel_dfs.h │ │ │ │ │ │ │ ├── SparseLU_pivotL.h │ │ │ │ │ │ │ ├── SparseLU_pruneL.h │ │ │ │ │ │ │ └── SparseLU_relax_snode.h │ │ │ │ │ │ ├── SparseQR/ │ │ │ │ │ │ │ └── SparseQR.h │ │ │ │ │ │ ├── StlSupport/ │ │ │ │ │ │ │ ├── StdDeque.h │ │ │ │ │ │ │ ├── StdList.h │ │ │ │ │ │ │ ├── StdVector.h │ │ │ │ │ │ │ └── details.h │ │ │ │ │ │ ├── SuperLUSupport/ │ │ │ │ │ │ │ └── SuperLUSupport.h │ │ │ │ │ │ ├── UmfPackSupport/ │ │ │ │ │ │ │ └── UmfPackSupport.h │ │ │ │ │ │ ├── misc/ │ │ │ │ │ │ │ ├── Image.h │ │ │ │ │ │ │ ├── Kernel.h │ │ │ │ │ │ │ ├── RealSvd2x2.h │ │ │ │ │ │ │ ├── blas.h │ │ │ │ │ │ │ ├── lapack.h │ │ │ │ │ │ │ ├── lapacke.h │ │ │ │ │ │ │ └── lapacke_mangling.h │ │ │ │ │ │ └── plugins/ │ │ │ │ │ │ ├── ArrayCwiseBinaryOps.h │ │ │ │ │ │ ├── ArrayCwiseUnaryOps.h │ │ │ │ │ │ ├── BlockMethods.h │ │ │ │ │ │ ├── CommonCwiseBinaryOps.h │ │ │ │ │ │ ├── CommonCwiseUnaryOps.h │ │ │ │ │ │ ├── MatrixCwiseBinaryOps.h │ │ │ │ │ │ └── MatrixCwiseUnaryOps.h │ │ │ │ │ └── Eigen.h │ │ │ │ ├── HX8347D/ │ │ │ │ │ ├── LCD.cpp │ │ │ │ │ ├── LCD.h │ │ │ │ │ ├── font.c │ │ │ │ │ └── font.h │ │ │ │ ├── I2Cdev/ │ │ │ │ │ ├── I2Cdev.cpp │ │ │ │ │ ├── I2Cdev.h │ │ │ │ │ ├── keywords.txt │ │ │ │ │ └── library.json │ │ │ │ ├── IMU/ │ │ │ │ │ ├── Define.h │ │ │ │ │ ├── ICM20648.cpp │ │ │ │ │ ├── ICM20648.h │ │ │ │ │ ├── ICM20648_REGS.h │ │ │ │ │ ├── IMU.cpp │ │ │ │ │ ├── IMU.h │ │ │ │ │ ├── MPU9250.cpp │ │ │ │ │ ├── MPU9250.h │ │ │ │ │ ├── MPU9250_REGS.h │ │ │ │ │ ├── MadgwickAHRS.cpp │ │ │ │ │ ├── MadgwickAHRS.h │ │ │ │ │ ├── imu_selector.cpp │ │ │ │ │ ├── imu_selector.h │ │ │ │ │ ├── imu_spi.cpp │ │ │ │ │ ├── imu_spi.h │ │ │ │ │ └── keywords.txt │ │ │ │ ├── LcdTouchPanel/ │ │ │ │ │ ├── LcdTouchPanel.cpp │ │ │ │ │ ├── LcdTouchPanel.h │ │ │ │ │ └── library.properties │ │ │ │ ├── OLLO/ │ │ │ │ │ ├── OLLO.cpp │ │ │ │ │ ├── OLLO.h │ │ │ │ │ └── keywords.txt │ │ │ │ ├── OP3/ │ │ │ │ │ ├── OP3.cpp │ │ │ │ │ ├── OP3.h │ │ │ │ │ └── examples/ │ │ │ │ │ └── opencr_op3/ │ │ │ │ │ ├── dxl.cpp │ │ │ │ │ ├── dxl.h │ │ │ │ │ ├── dxl_debug.cpp │ │ │ │ │ ├── dxl_debug.h │ │ │ │ │ ├── dxl_def.h │ │ │ │ │ ├── dxl_hw.cpp │ │ │ │ │ ├── dxl_hw.h │ │ │ │ │ ├── dxl_hw_op3.cpp │ │ │ │ │ ├── dxl_hw_op3.h │ │ │ │ │ ├── dxl_node_op3.cpp │ │ │ │ │ ├── dxl_node_op3.h │ │ │ │ │ └── opencr_op3.ino │ │ │ │ ├── OpenCR/ │ │ │ │ │ ├── OpenCR.cpp │ │ │ │ │ ├── OpenCR.h │ │ │ │ │ └── examples/ │ │ │ │ │ ├── 01. Basics/ │ │ │ │ │ │ ├── a_Bare_Minimum/ │ │ │ │ │ │ │ └── a_Bare_Minimum.ino │ │ │ │ │ │ ├── b_Blink_LED/ │ │ │ │ │ │ │ └── b_Blink_LED.ino │ │ │ │ │ │ ├── c_Digital_Read_Serial/ │ │ │ │ │ │ │ └── c_Digital_Read_Serial.ino │ │ │ │ │ │ ├── d_Analog_Read_Serial/ │ │ │ │ │ │ │ └── d_Analog_Read_Serial.ino │ │ │ │ │ │ ├── e_Read_Analog_Voltage/ │ │ │ │ │ │ │ └── e_Read_Analog_Voltage.ino │ │ │ │ │ │ └── f_Gpio_Write_Speed_Test/ │ │ │ │ │ │ └── f_Gpio_Write_Speed_Test.ino │ │ │ │ │ ├── 02. Digital/ │ │ │ │ │ │ ├── a_toneMelody/ │ │ │ │ │ │ │ ├── a_toneMelody.ino │ │ │ │ │ │ │ └── pitches.h │ │ │ │ │ │ └── b_PWM/ │ │ │ │ │ │ └── b_PWM.ino │ │ │ │ │ ├── 03. Communication/ │ │ │ │ │ │ └── a_Serial_HelloWorld/ │ │ │ │ │ │ └── a_Serial_HelloWorld.ino │ │ │ │ │ ├── 04. Interrupt/ │ │ │ │ │ │ ├── a_EXIT_Interrupt_Serial/ │ │ │ │ │ │ │ └── a_EXIT_Interrupt_Serial.ino │ │ │ │ │ │ └── d_Timer_Interrupt_LED/ │ │ │ │ │ │ └── d_Timer_Interrupt_LED.ino │ │ │ │ │ ├── 05. Sensors/ │ │ │ │ │ │ ├── OLLO_COLOR_Read/ │ │ │ │ │ │ │ └── OLLO_COLOR_Read.ino │ │ │ │ │ │ ├── OLLO_DMS_Read/ │ │ │ │ │ │ │ └── OLLO_DMS_Read.ino │ │ │ │ │ │ ├── OLLO_IR_Read/ │ │ │ │ │ │ │ └── OLLO_IR_Read.ino │ │ │ │ │ │ ├── OLLO_TOUCH_Read/ │ │ │ │ │ │ │ └── OLLO_TOUCH_Read.ino │ │ │ │ │ │ └── OLLO_TPS_READ/ │ │ │ │ │ │ └── OLLO_TPS_READ.ino │ │ │ │ │ ├── 06. RC100/ │ │ │ │ │ │ └── RC100/ │ │ │ │ │ │ └── RC100.ino │ │ │ │ │ ├── 07. DynamixelSDK/ │ │ │ │ │ │ ├── dxl_monitor/ │ │ │ │ │ │ │ └── dxl_monitor.ino │ │ │ │ │ │ ├── protocol1.0/ │ │ │ │ │ │ │ ├── bulk_read/ │ │ │ │ │ │ │ │ └── bulk_read.ino │ │ │ │ │ │ │ ├── ping/ │ │ │ │ │ │ │ │ └── ping.ino │ │ │ │ │ │ │ ├── read_write/ │ │ │ │ │ │ │ │ └── read_write.ino │ │ │ │ │ │ │ ├── reset/ │ │ │ │ │ │ │ │ └── reset.ino │ │ │ │ │ │ │ └── sync_write/ │ │ │ │ │ │ │ └── sync_write.ino │ │ │ │ │ │ ├── protocol2.0/ │ │ │ │ │ │ │ ├── broadcast_ping/ │ │ │ │ │ │ │ │ └── broadcast_ping.ino │ │ │ │ │ │ │ ├── bulk_read_write/ │ │ │ │ │ │ │ │ └── bulk_read_write.ino │ │ │ │ │ │ │ ├── factory_reset/ │ │ │ │ │ │ │ │ └── factory_reset.ino │ │ │ │ │ │ │ ├── indirect_address/ │ │ │ │ │ │ │ │ └── indirect_address.ino │ │ │ │ │ │ │ ├── ping/ │ │ │ │ │ │ │ │ └── ping.ino │ │ │ │ │ │ │ ├── read_write/ │ │ │ │ │ │ │ │ └── read_write.ino │ │ │ │ │ │ │ ├── reboot/ │ │ │ │ │ │ │ │ └── reboot.ino │ │ │ │ │ │ │ └── sync_read_write/ │ │ │ │ │ │ │ └── sync_read_write.ino │ │ │ │ │ │ └── protocol_combined/ │ │ │ │ │ │ └── protocol_combined.ino │ │ │ │ │ ├── 08. DynamixelWorkbench/ │ │ │ │ │ │ ├── a_Model_Scan/ │ │ │ │ │ │ │ └── a_Model_Scan.ino │ │ │ │ │ │ ├── b_Ping/ │ │ │ │ │ │ │ └── b_Ping.ino │ │ │ │ │ │ ├── c_ID_Change/ │ │ │ │ │ │ │ └── c_ID_Change.ino │ │ │ │ │ │ ├── d_BPS_Change/ │ │ │ │ │ │ │ └── d_BPS_Change.ino │ │ │ │ │ │ ├── e_Mode_Change/ │ │ │ │ │ │ │ └── e_Mode_Change.ino │ │ │ │ │ │ ├── f_Reboot/ │ │ │ │ │ │ │ └── f_Reboot.ino │ │ │ │ │ │ ├── g_Reset/ │ │ │ │ │ │ │ └── g_Reset.ino │ │ │ │ │ │ ├── h_Position/ │ │ │ │ │ │ │ └── h_Position.ino │ │ │ │ │ │ ├── i_Velocity/ │ │ │ │ │ │ │ └── i_Velocity.ino │ │ │ │ │ │ ├── j_Current_Based_Position/ │ │ │ │ │ │ │ └── j_Current_Based_Position.ino │ │ │ │ │ │ ├── k_Read_Write/ │ │ │ │ │ │ │ └── k_Read_Write.ino │ │ │ │ │ │ ├── l_Sync_Write/ │ │ │ │ │ │ │ └── l_Sync_Write.ino │ │ │ │ │ │ ├── m_Sync_Read_Write/ │ │ │ │ │ │ │ └── m_Sync_Read_Write.ino │ │ │ │ │ │ ├── n_Bulk_Read_Write/ │ │ │ │ │ │ │ └── n_Bulk_Read_Write.ino │ │ │ │ │ │ ├── o_Find_Dynamixel/ │ │ │ │ │ │ │ └── o_Find_Dynamixel.ino │ │ │ │ │ │ └── p_Monitor/ │ │ │ │ │ │ └── p_Monitor.ino │ │ │ │ │ ├── 09. IMU/ │ │ │ │ │ │ ├── IMU_Read_AccRAW/ │ │ │ │ │ │ │ └── IMU_Read_AccRAW.ino │ │ │ │ │ │ ├── IMU_Read_GyroRAW/ │ │ │ │ │ │ │ └── IMU_Read_GyroRAW.ino │ │ │ │ │ │ └── IMU_Read_RollPitchYaw/ │ │ │ │ │ │ └── IMU_Read_RollPitchYaw.ino │ │ │ │ │ └── 10. Etc/ │ │ │ │ │ ├── CAMERA/ │ │ │ │ │ │ └── ov7725_al422b/ │ │ │ │ │ │ ├── ov7725_al422b.cpp │ │ │ │ │ │ ├── ov7725_al422b.h │ │ │ │ │ │ ├── ov7725_al422b.ino │ │ │ │ │ │ ├── settings.h │ │ │ │ │ │ └── src/ │ │ │ │ │ │ ├── OV7725/ │ │ │ │ │ │ │ ├── OV7725.cpp │ │ │ │ │ │ │ └── OV7725.h │ │ │ │ │ │ ├── sccb/ │ │ │ │ │ │ │ ├── sccb.c │ │ │ │ │ │ │ └── sccb.h │ │ │ │ │ │ ├── tftLcd.cpp │ │ │ │ │ │ └── tftLcd.h │ │ │ │ │ ├── CAN/ │ │ │ │ │ │ ├── canMaskFilter/ │ │ │ │ │ │ │ └── canMaskFilter.ino │ │ │ │ │ │ ├── canRxInterrupt/ │ │ │ │ │ │ │ └── canRxInterrupt.ino │ │ │ │ │ │ ├── canTxRxByte/ │ │ │ │ │ │ │ └── canTxRxByte.ino │ │ │ │ │ │ └── canTxRxMessage/ │ │ │ │ │ │ └── canTxRxMessage.ino │ │ │ │ │ ├── EEPROM/ │ │ │ │ │ │ ├── eeprom_clear/ │ │ │ │ │ │ │ └── eeprom_clear.ino │ │ │ │ │ │ ├── eeprom_crc/ │ │ │ │ │ │ │ └── eeprom_crc.ino │ │ │ │ │ │ ├── eeprom_get/ │ │ │ │ │ │ │ └── eeprom_get.ino │ │ │ │ │ │ ├── eeprom_iteration/ │ │ │ │ │ │ │ └── eeprom_iteration.ino │ │ │ │ │ │ ├── eeprom_put/ │ │ │ │ │ │ │ └── eeprom_put.ino │ │ │ │ │ │ ├── eeprom_read/ │ │ │ │ │ │ │ └── eeprom_read.ino │ │ │ │ │ │ ├── eeprom_update/ │ │ │ │ │ │ │ └── eeprom_update.ino │ │ │ │ │ │ └── eeprom_write/ │ │ │ │ │ │ └── eeprom_write.ino │ │ │ │ │ ├── Eigen/ │ │ │ │ │ │ └── eigen_test/ │ │ │ │ │ │ └── eigen_test.ino │ │ │ │ │ ├── FreeRTOS/ │ │ │ │ │ │ └── thread_led/ │ │ │ │ │ │ └── thread_led.ino │ │ │ │ │ ├── LDS/ │ │ │ │ │ │ └── drawLDS/ │ │ │ │ │ │ ├── drawLDS.ino │ │ │ │ │ │ ├── lds.cpp │ │ │ │ │ │ └── lds.h │ │ │ │ │ ├── SPI/ │ │ │ │ │ │ └── using_SPI_ports/ │ │ │ │ │ │ └── using_SPI_ports.ino │ │ │ │ │ ├── Servo/ │ │ │ │ │ │ ├── Knob/ │ │ │ │ │ │ │ └── Knob.ino │ │ │ │ │ │ └── Sweep/ │ │ │ │ │ │ └── Sweep.ino │ │ │ │ │ ├── TFT/ │ │ │ │ │ │ ├── tft_shape/ │ │ │ │ │ │ │ └── tft_shape/ │ │ │ │ │ │ │ └── tft_shape.ino │ │ │ │ │ │ ├── tft_text/ │ │ │ │ │ │ │ └── tft_text/ │ │ │ │ │ │ │ └── tft_text.ino │ │ │ │ │ │ └── tft_touch/ │ │ │ │ │ │ └── tft_touch/ │ │ │ │ │ │ └── tft_touch.ino │ │ │ │ │ ├── Waveshare/ │ │ │ │ │ │ ├── breakouttouchpaint/ │ │ │ │ │ │ │ └── breakouttouchpaint.ino │ │ │ │ │ │ ├── graphicstest/ │ │ │ │ │ │ │ └── graphicstest.ino │ │ │ │ │ │ ├── lcd_logo/ │ │ │ │ │ │ │ ├── lcd_logo.ino │ │ │ │ │ │ │ ├── logo.cpp │ │ │ │ │ │ │ └── logo.h │ │ │ │ │ │ ├── spitftbitmap/ │ │ │ │ │ │ │ └── spitftbitmap.ino │ │ │ │ │ │ └── tft_box/ │ │ │ │ │ │ └── tft_box.ino │ │ │ │ │ ├── rtc_time/ │ │ │ │ │ │ └── rtc_time.ino │ │ │ │ │ └── usb_to_dxl/ │ │ │ │ │ └── usb_to_dxl.ino │ │ │ │ ├── OpenManipulator/ │ │ │ │ │ ├── example/ │ │ │ │ │ │ ├── Chain/ │ │ │ │ │ │ │ ├── open_manipulator_chain/ │ │ │ │ │ │ │ │ ├── demo.h │ │ │ │ │ │ │ │ ├── open_manipulator_chain.ino │ │ │ │ │ │ │ │ ├── processing.h │ │ │ │ │ │ │ │ └── remote_controller.h │ │ │ │ │ │ │ ├── open_manipulator_chain_ROS/ │ │ │ │ │ │ │ │ ├── open_manipulator_chain_ROS.h │ │ │ │ │ │ │ │ └── open_manipulator_chain_ROS.ino │ │ │ │ │ │ │ ├── open_manipulator_chain_pen/ │ │ │ │ │ │ │ │ ├── open_manipulator_chain_pen.ino │ │ │ │ │ │ │ │ ├── open_manipulator_pen.h │ │ │ │ │ │ │ │ ├── open_manipulator_pen_drawing.cpp │ │ │ │ │ │ │ │ ├── open_manipulator_pen_drawing.h │ │ │ │ │ │ │ │ ├── open_manipulator_pen_motion.h │ │ │ │ │ │ │ │ └── processing.h │ │ │ │ │ │ │ ├── open_manipulator_chain_teaching/ │ │ │ │ │ │ │ │ └── open_manipulator_chain_teaching.ino │ │ │ │ │ │ │ └── open_manipulator_chain_vacuum/ │ │ │ │ │ │ │ ├── actuator.h │ │ │ │ │ │ │ ├── open_manipulator_chain_vacuum.ino │ │ │ │ │ │ │ ├── open_manipulator_vacuum.h │ │ │ │ │ │ │ ├── open_manipulator_vacuum_motion.h │ │ │ │ │ │ │ └── processing.h │ │ │ │ │ │ ├── Delta/ │ │ │ │ │ │ │ └── open_manipulator_delta/ │ │ │ │ │ │ │ ├── demo.h │ │ │ │ │ │ │ ├── open_manipulator_delta.ino │ │ │ │ │ │ │ ├── processing.h │ │ │ │ │ │ │ └── remotecontroller100.h │ │ │ │ │ │ ├── Linear/ │ │ │ │ │ │ │ └── open_manipulator_linear/ │ │ │ │ │ │ │ ├── demo.h │ │ │ │ │ │ │ ├── open_manipulator_linear.ino │ │ │ │ │ │ │ ├── processing.h │ │ │ │ │ │ │ └── remotecontroller100.h │ │ │ │ │ │ ├── Link/ │ │ │ │ │ │ │ └── open_manipulator_link/ │ │ │ │ │ │ │ ├── link.h │ │ │ │ │ │ │ ├── link_kinematics.h │ │ │ │ │ │ │ ├── motion.h │ │ │ │ │ │ │ ├── open_manipulator_link.ino │ │ │ │ │ │ │ ├── processing.h │ │ │ │ │ │ │ ├── remote_controller.h │ │ │ │ │ │ │ └── vacuum_actuator.h │ │ │ │ │ │ ├── Planar/ │ │ │ │ │ │ │ └── open_manipulator_planar/ │ │ │ │ │ │ │ ├── demo.h │ │ │ │ │ │ │ ├── open_manipulator_planar.ino │ │ │ │ │ │ │ ├── processing.h │ │ │ │ │ │ │ └── remotecontroller100.h │ │ │ │ │ │ ├── Scara/ │ │ │ │ │ │ │ └── open_manipulator_scara/ │ │ │ │ │ │ │ ├── demo.h │ │ │ │ │ │ │ ├── open_manipulator_scara.ino │ │ │ │ │ │ │ ├── processing.h │ │ │ │ │ │ │ └── remotecontroller100.h │ │ │ │ │ │ └── Stewart/ │ │ │ │ │ │ └── open_manipulator_stewart/ │ │ │ │ │ │ ├── demo.h │ │ │ │ │ │ ├── demo2.h │ │ │ │ │ │ ├── open_manipulator_stewart.ino │ │ │ │ │ │ ├── processing.h │ │ │ │ │ │ └── remotecontroller100.h │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── delta_libs/ │ │ │ │ │ │ ├── include/ │ │ │ │ │ │ │ └── delta_libs/ │ │ │ │ │ │ │ ├── delta.h │ │ │ │ │ │ │ ├── delta_custom_trajectory.h │ │ │ │ │ │ │ ├── delta_dynamixel.h │ │ │ │ │ │ │ └── delta_kinematics.h │ │ │ │ │ │ └── src/ │ │ │ │ │ │ ├── delta.cpp │ │ │ │ │ │ ├── delta_custom_trajectory.cpp │ │ │ │ │ │ ├── delta_dynamixel.cpp │ │ │ │ │ │ └── delta_kinematics.cpp │ │ │ │ │ ├── delta_libs.h │ │ │ │ │ ├── linear_libs/ │ │ │ │ │ │ ├── include/ │ │ │ │ │ │ │ └── linear_libs/ │ │ │ │ │ │ │ ├── linear.h │ │ │ │ │ │ │ ├── linear_custom_trajectory.h │ │ │ │ │ │ │ ├── linear_dynamixel.h │ │ │ │ │ │ │ └── linear_kinematics.h │ │ │ │ │ │ └── src/ │ │ │ │ │ │ ├── linear.cpp │ │ │ │ │ │ ├── linear_custom_trajectory.cpp │ │ │ │ │ │ ├── linear_dynamixel.cpp │ │ │ │ │ │ └── linear_kinematics.cpp │ │ │ │ │ ├── linear_libs.h │ │ │ │ │ ├── open_manipulator_libs/ │ │ │ │ │ │ ├── include/ │ │ │ │ │ │ │ └── open_manipulator_libs/ │ │ │ │ │ │ │ ├── custom_trajectory.h │ │ │ │ │ │ │ ├── dynamixel.h │ │ │ │ │ │ │ ├── kinematics.h │ │ │ │ │ │ │ └── open_manipulator.h │ │ │ │ │ │ └── src/ │ │ │ │ │ │ ├── custom_trajectory.cpp │ │ │ │ │ │ ├── dynamixel.cpp │ │ │ │ │ │ ├── kinematics.cpp │ │ │ │ │ │ └── open_manipulator.cpp │ │ │ │ │ ├── open_manipulator_libs.h │ │ │ │ │ ├── open_manipulator_msgs/ │ │ │ │ │ │ ├── GetJointPosition.h │ │ │ │ │ │ ├── GetKinematicsPose.h │ │ │ │ │ │ ├── JointPosition.h │ │ │ │ │ │ ├── KinematicsPose.h │ │ │ │ │ │ ├── OpenManipulatorState.h │ │ │ │ │ │ ├── SetActuatorState.h │ │ │ │ │ │ ├── SetDrawingTrajectory.h │ │ │ │ │ │ ├── SetJointPosition.h │ │ │ │ │ │ └── SetKinematicsPose.h │ │ │ │ │ ├── planar_libs/ │ │ │ │ │ │ ├── include/ │ │ │ │ │ │ │ └── planar_libs/ │ │ │ │ │ │ │ ├── planar.h │ │ │ │ │ │ │ ├── planar_custom_trajectory.h │ │ │ │ │ │ │ ├── planar_dynamixel.h │ │ │ │ │ │ │ └── planar_kinematics.h │ │ │ │ │ │ └── src/ │ │ │ │ │ │ ├── planar.cpp │ │ │ │ │ │ ├── planar_custom_trajectory.cpp │ │ │ │ │ │ ├── planar_dynamixel.cpp │ │ │ │ │ │ └── planar_kinematics.cpp │ │ │ │ │ ├── planar_libs.h │ │ │ │ │ ├── scara_libs/ │ │ │ │ │ │ ├── include/ │ │ │ │ │ │ │ └── scara_libs/ │ │ │ │ │ │ │ ├── scara.h │ │ │ │ │ │ │ ├── scara_custom_trajectory.h │ │ │ │ │ │ │ ├── scara_dynamixel.h │ │ │ │ │ │ │ └── scara_kinematics.h │ │ │ │ │ │ └── src/ │ │ │ │ │ │ ├── scara.cpp │ │ │ │ │ │ ├── scara_custom_trajectory.cpp │ │ │ │ │ │ ├── scara_dynamixel.cpp │ │ │ │ │ │ └── scara_kinematics.cpp │ │ │ │ │ ├── scara_libs.h │ │ │ │ │ ├── stewart_libs/ │ │ │ │ │ │ ├── include/ │ │ │ │ │ │ │ └── stewart_libs/ │ │ │ │ │ │ │ ├── stewart.h │ │ │ │ │ │ │ ├── stewart_custom_trajectory.h │ │ │ │ │ │ │ ├── stewart_dynamixel.h │ │ │ │ │ │ │ └── stewart_kinematics.h │ │ │ │ │ │ └── src/ │ │ │ │ │ │ ├── stewart.cpp │ │ │ │ │ │ ├── stewart_custom_trajectory.cpp │ │ │ │ │ │ ├── stewart_dynamixel.cpp │ │ │ │ │ │ └── stewart_kinematics.cpp │ │ │ │ │ └── stewart_libs.h │ │ │ │ ├── RC100/ │ │ │ │ │ ├── RC100.cpp │ │ │ │ │ └── RC100.h │ │ │ │ ├── ROS/ │ │ │ │ │ ├── OpenCR_ROS.cpp │ │ │ │ │ ├── OpenCR_ROS.h │ │ │ │ │ └── examples/ │ │ │ │ │ ├── 01. Basics/ │ │ │ │ │ │ ├── a_LED/ │ │ │ │ │ │ │ └── a_LED.ino │ │ │ │ │ │ ├── b_Button/ │ │ │ │ │ │ │ └── b_Button.ino │ │ │ │ │ │ ├── c_Voltage/ │ │ │ │ │ │ │ └── c_Voltage.ino │ │ │ │ │ │ └── d_IMU/ │ │ │ │ │ │ └── d_IMU.ino │ │ │ │ │ └── 02. Sensors/ │ │ │ │ │ ├── a_bumper/ │ │ │ │ │ │ └── a_bumper.ino │ │ │ │ │ ├── b_cliff/ │ │ │ │ │ │ └── b_cliff.ino │ │ │ │ │ ├── c_Ultrasonic/ │ │ │ │ │ │ └── c_Ultrasonic.ino │ │ │ │ │ └── d_Illumination/ │ │ │ │ │ └── d_Illumination.ino │ │ │ │ ├── RTOS/ │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── FreeRTOS.h │ │ │ │ │ ├── FreeRTOSConfig.h │ │ │ │ │ ├── RTOS.cpp │ │ │ │ │ ├── RTOS.h │ │ │ │ │ ├── StackMacros.h │ │ │ │ │ ├── cmsis_os.c │ │ │ │ │ ├── cmsis_os.h │ │ │ │ │ ├── croutine.c │ │ │ │ │ ├── croutine.h │ │ │ │ │ ├── deprecated_definitions.h │ │ │ │ │ ├── event_groups.c │ │ │ │ │ ├── event_groups.h │ │ │ │ │ ├── heap_3.c │ │ │ │ │ ├── list.c │ │ │ │ │ ├── list.h │ │ │ │ │ ├── mpu_wrappers.h │ │ │ │ │ ├── port.c │ │ │ │ │ ├── portable.h │ │ │ │ │ ├── portmacro.h │ │ │ │ │ ├── projdefs.h │ │ │ │ │ ├── queue.c │ │ │ │ │ ├── queue.h │ │ │ │ │ ├── readme.txt │ │ │ │ │ ├── semphr.h │ │ │ │ │ ├── st_readme.txt │ │ │ │ │ ├── stdint.readme │ │ │ │ │ ├── task.h │ │ │ │ │ ├── tasks.c │ │ │ │ │ ├── timers.c │ │ │ │ │ └── timers.h │ │ │ │ ├── RobotisManipulator/ │ │ │ │ │ ├── include/ │ │ │ │ │ │ └── robotis_manipulator/ │ │ │ │ │ │ ├── robotis_manipulator.h │ │ │ │ │ │ ├── robotis_manipulator_common.h │ │ │ │ │ │ ├── robotis_manipulator_log.h │ │ │ │ │ │ ├── robotis_manipulator_manager.h │ │ │ │ │ │ ├── robotis_manipulator_math.h │ │ │ │ │ │ └── robotis_manipulator_trajectory_generator.h │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── RobotisManipulator.h │ │ │ │ │ └── robotis_manipulator/ │ │ │ │ │ ├── robotis_manipulator.cpp │ │ │ │ │ ├── robotis_manipulator_common.cpp │ │ │ │ │ ├── robotis_manipulator_log.cpp │ │ │ │ │ ├── robotis_manipulator_manager.cpp │ │ │ │ │ ├── robotis_manipulator_math.cpp │ │ │ │ │ └── robotis_manipulator_trajectory_generator.cpp │ │ │ │ ├── SPI/ │ │ │ │ │ ├── EventResponder.cpp │ │ │ │ │ ├── EventResponder.h │ │ │ │ │ ├── SPI.cpp │ │ │ │ │ ├── SPI.h │ │ │ │ │ └── keywords.txt │ │ │ │ ├── Servo/ │ │ │ │ │ ├── README.adoc │ │ │ │ │ ├── keywords.txt │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── Servo.cpp │ │ │ │ │ └── Servo.h │ │ │ │ ├── Touch/ │ │ │ │ │ ├── Touch.cpp │ │ │ │ │ └── Touch.h │ │ │ │ ├── Waveshare_HX8347D/ │ │ │ │ │ ├── README.txt │ │ │ │ │ ├── Waveshare_HX8347D.cpp │ │ │ │ │ ├── Waveshare_HX8347D.h │ │ │ │ │ └── library.properties │ │ │ │ ├── Wire/ │ │ │ │ │ ├── README │ │ │ │ │ ├── SlowSoftI2CMaster.cpp │ │ │ │ │ ├── SlowSoftI2CMaster.h │ │ │ │ │ ├── Wire.cpp │ │ │ │ │ ├── Wire.h │ │ │ │ │ └── keywords.txt │ │ │ │ ├── XPT2046/ │ │ │ │ │ ├── XPT2046.cpp │ │ │ │ │ └── XPT2046.h │ │ │ │ ├── turtlebot3/ │ │ │ │ │ ├── examples/ │ │ │ │ │ │ ├── turtlebot3_burger/ │ │ │ │ │ │ │ └── turtlebot3_core/ │ │ │ │ │ │ │ ├── turtlebot3_burger.h │ │ │ │ │ │ │ ├── turtlebot3_core.ino │ │ │ │ │ │ │ └── turtlebot3_core_config.h │ │ │ │ │ │ ├── turtlebot3_friends/ │ │ │ │ │ │ │ ├── turtlebot3_bike/ │ │ │ │ │ │ │ │ ├── turtlebot3_bike.h │ │ │ │ │ │ │ │ ├── turtlebot3_bike.ino │ │ │ │ │ │ │ │ ├── turtlebot3_bike_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_bike_motor_driver.h │ │ │ │ │ │ │ ├── turtlebot3_car/ │ │ │ │ │ │ │ │ ├── turtlebot3_car.h │ │ │ │ │ │ │ │ ├── turtlebot3_car.ino │ │ │ │ │ │ │ │ ├── turtlebot3_car_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_car_motor_driver.h │ │ │ │ │ │ │ ├── turtlebot3_conveyor/ │ │ │ │ │ │ │ │ ├── turtlebot3_conveyor.h │ │ │ │ │ │ │ │ ├── turtlebot3_conveyor.ino │ │ │ │ │ │ │ │ ├── turtlebot3_conveyor_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_conveyor_motor_driver.h │ │ │ │ │ │ │ ├── turtlebot3_mecanum/ │ │ │ │ │ │ │ │ ├── turtlebot3_mecanum.h │ │ │ │ │ │ │ │ ├── turtlebot3_mecanum.ino │ │ │ │ │ │ │ │ ├── turtlebot3_mecanum_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_mecanum_motor_driver.h │ │ │ │ │ │ │ ├── turtlebot3_monster/ │ │ │ │ │ │ │ │ ├── turtlebot3_monster.h │ │ │ │ │ │ │ │ ├── turtlebot3_monster.ino │ │ │ │ │ │ │ │ ├── turtlebot3_monster_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_monster_motor_driver.h │ │ │ │ │ │ │ ├── turtlebot3_omni/ │ │ │ │ │ │ │ │ ├── turtlebot3_omni.h │ │ │ │ │ │ │ │ ├── turtlebot3_omni.ino │ │ │ │ │ │ │ │ ├── turtlebot3_omni_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_omni_motor_driver.h │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot/ │ │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot.h │ │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot.ino │ │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot_motion.h │ │ │ │ │ │ │ │ ├── turtlebot3_realturtlebot_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_realturtlebot_motor_driver.h │ │ │ │ │ │ │ ├── turtlebot3_road_train/ │ │ │ │ │ │ │ │ ├── turtlebot3_road_train.h │ │ │ │ │ │ │ │ ├── turtlebot3_road_train.ino │ │ │ │ │ │ │ │ ├── turtlebot3_road_train_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_road_train_motor_driver.h │ │ │ │ │ │ │ ├── turtlebot3_segway/ │ │ │ │ │ │ │ │ ├── turtlebot3_segway.h │ │ │ │ │ │ │ │ ├── turtlebot3_segway.ino │ │ │ │ │ │ │ │ ├── turtlebot3_segway_motor_driver.cpp │ │ │ │ │ │ │ │ └── turtlebot3_segway_motor_driver.h │ │ │ │ │ │ │ └── turtlebot3_tank/ │ │ │ │ │ │ │ ├── turtlebot3_tank.h │ │ │ │ │ │ │ ├── turtlebot3_tank.ino │ │ │ │ │ │ │ ├── turtlebot3_tank_motor_driver.cpp │ │ │ │ │ │ │ └── turtlebot3_tank_motor_driver.h │ │ │ │ │ │ ├── turtlebot3_setup/ │ │ │ │ │ │ │ └── turtlebot3_setup_motor/ │ │ │ │ │ │ │ └── turtlebot3_setup_motor.ino │ │ │ │ │ │ ├── turtlebot3_waffle/ │ │ │ │ │ │ │ └── turtlebot3_core/ │ │ │ │ │ │ │ ├── turtlebot3_core.ino │ │ │ │ │ │ │ ├── turtlebot3_core_config.h │ │ │ │ │ │ │ └── turtlebot3_waffle.h │ │ │ │ │ │ └── turtlebot3_with_open_manipulator/ │ │ │ │ │ │ └── turtlebot3_with_open_manipulator_core/ │ │ │ │ │ │ ├── open_manipulator_driver.cpp │ │ │ │ │ │ ├── open_manipulator_driver.h │ │ │ │ │ │ ├── turtlebot3_with_open_manipulator.h │ │ │ │ │ │ ├── turtlebot3_with_open_manipulator_core.ino │ │ │ │ │ │ └── turtlebot3_with_open_manipulator_core_config.h │ │ │ │ │ ├── include/ │ │ │ │ │ │ └── turtlebot3/ │ │ │ │ │ │ ├── turtlebot3.h │ │ │ │ │ │ ├── turtlebot3_controller.h │ │ │ │ │ │ ├── turtlebot3_diagnosis.h │ │ │ │ │ │ ├── turtlebot3_motor_driver.h │ │ │ │ │ │ └── turtlebot3_sensor.h │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── TurtleBot3.h │ │ │ │ │ └── turtlebot3/ │ │ │ │ │ ├── turtlebot3_controller.cpp │ │ │ │ │ ├── turtlebot3_diagnosis.cpp │ │ │ │ │ ├── turtlebot3_motor_driver.cpp │ │ │ │ │ └── turtlebot3_sensor.cpp │ │ │ │ ├── turtlebot3_ros2/ │ │ │ │ │ ├── examples/ │ │ │ │ │ │ ├── turtlebot3_burger/ │ │ │ │ │ │ │ └── turtlebot3_burger.ino │ │ │ │ │ │ ├── turtlebot3_manipulation/ │ │ │ │ │ │ │ └── turtlebot3_manipulation.ino │ │ │ │ │ │ └── turtlebot3_waffle/ │ │ │ │ │ │ └── turtlebot3_waffle.ino │ │ │ │ │ ├── include/ │ │ │ │ │ │ └── turtlebot3/ │ │ │ │ │ │ ├── open_manipulator_driver.h │ │ │ │ │ │ ├── turtlebot3.h │ │ │ │ │ │ ├── turtlebot3_controller.h │ │ │ │ │ │ ├── turtlebot3_diagnosis.h │ │ │ │ │ │ ├── turtlebot3_motor_driver.h │ │ │ │ │ │ └── turtlebot3_sensor.h │ │ │ │ │ ├── library.properties │ │ │ │ │ └── src/ │ │ │ │ │ ├── TurtleBot3_ROS2.h │ │ │ │ │ └── turtlebot3/ │ │ │ │ │ ├── open_manipulator_driver.cpp │ │ │ │ │ ├── turtlebot3.cpp │ │ │ │ │ ├── turtlebot3_controller.cpp │ │ │ │ │ ├── turtlebot3_diagnosis.cpp │ │ │ │ │ ├── turtlebot3_motor_driver.cpp │ │ │ │ │ └── turtlebot3_sensor.cpp │ │ │ │ └── turtlebot3_ros_lib/ │ │ │ │ ├── ArduinoHardware.h │ │ │ │ ├── duration.cpp │ │ │ │ ├── geometry_msgs/ │ │ │ │ │ ├── Accel.h │ │ │ │ │ ├── AccelStamped.h │ │ │ │ │ ├── AccelWithCovariance.h │ │ │ │ │ ├── AccelWithCovarianceStamped.h │ │ │ │ │ ├── Inertia.h │ │ │ │ │ ├── InertiaStamped.h │ │ │ │ │ ├── Point.h │ │ │ │ │ ├── Point32.h │ │ │ │ │ ├── PointStamped.h │ │ │ │ │ ├── Polygon.h │ │ │ │ │ ├── PolygonStamped.h │ │ │ │ │ ├── Pose.h │ │ │ │ │ ├── Pose2D.h │ │ │ │ │ ├── PoseArray.h │ │ │ │ │ ├── PoseStamped.h │ │ │ │ │ ├── PoseWithCovariance.h │ │ │ │ │ ├── PoseWithCovarianceStamped.h │ │ │ │ │ ├── Quaternion.h │ │ │ │ │ ├── QuaternionStamped.h │ │ │ │ │ ├── Transform.h │ │ │ │ │ ├── TransformStamped.h │ │ │ │ │ ├── Twist.h │ │ │ │ │ ├── TwistStamped.h │ │ │ │ │ ├── TwistWithCovariance.h │ │ │ │ │ ├── TwistWithCovarianceStamped.h │ │ │ │ │ ├── Vector3.h │ │ │ │ │ ├── Vector3Stamped.h │ │ │ │ │ ├── Wrench.h │ │ │ │ │ └── WrenchStamped.h │ │ │ │ ├── nav_msgs/ │ │ │ │ │ ├── GetMap.h │ │ │ │ │ ├── GetMapAction.h │ │ │ │ │ ├── GetMapActionFeedback.h │ │ │ │ │ ├── GetMapActionGoal.h │ │ │ │ │ ├── GetMapActionResult.h │ │ │ │ │ ├── GetMapFeedback.h │ │ │ │ │ ├── GetMapGoal.h │ │ │ │ │ ├── GetMapResult.h │ │ │ │ │ ├── GetPlan.h │ │ │ │ │ ├── GridCells.h │ │ │ │ │ ├── MapMetaData.h │ │ │ │ │ ├── OccupancyGrid.h │ │ │ │ │ ├── Odometry.h │ │ │ │ │ ├── Path.h │ │ │ │ │ └── SetMap.h │ │ │ │ ├── ros/ │ │ │ │ │ ├── duration.h │ │ │ │ │ ├── msg.h │ │ │ │ │ ├── node_handle.h │ │ │ │ │ ├── publisher.h │ │ │ │ │ ├── service_client.h │ │ │ │ │ ├── service_server.h │ │ │ │ │ ├── subscriber.h │ │ │ │ │ └── time.h │ │ │ │ ├── ros.h │ │ │ │ ├── roscpp/ │ │ │ │ │ ├── Empty.h │ │ │ │ │ ├── GetLoggers.h │ │ │ │ │ ├── Logger.h │ │ │ │ │ └── SetLoggerLevel.h │ │ │ │ ├── rosserial_arduino/ │ │ │ │ │ ├── Adc.h │ │ │ │ │ └── Test.h │ │ │ │ ├── rosserial_msgs/ │ │ │ │ │ ├── Log.h │ │ │ │ │ ├── RequestMessageInfo.h │ │ │ │ │ ├── RequestParam.h │ │ │ │ │ ├── RequestServiceInfo.h │ │ │ │ │ └── TopicInfo.h │ │ │ │ ├── sensor_msgs/ │ │ │ │ │ ├── BatteryState.h │ │ │ │ │ ├── BatteryStateNoetic.h │ │ │ │ │ ├── CameraInfo.h │ │ │ │ │ ├── ChannelFloat32.h │ │ │ │ │ ├── CompressedImage.h │ │ │ │ │ ├── FluidPressure.h │ │ │ │ │ ├── Illuminance.h │ │ │ │ │ ├── Image.h │ │ │ │ │ ├── Imu.h │ │ │ │ │ ├── JointState.h │ │ │ │ │ ├── Joy.h │ │ │ │ │ ├── JoyFeedback.h │ │ │ │ │ ├── JoyFeedbackArray.h │ │ │ │ │ ├── LaserEcho.h │ │ │ │ │ ├── LaserScan.h │ │ │ │ │ ├── MagneticField.h │ │ │ │ │ ├── MultiDOFJointState.h │ │ │ │ │ ├── MultiEchoLaserScan.h │ │ │ │ │ ├── NavSatFix.h │ │ │ │ │ ├── NavSatStatus.h │ │ │ │ │ ├── PointCloud.h │ │ │ │ │ ├── PointCloud2.h │ │ │ │ │ ├── PointField.h │ │ │ │ │ ├── Range.h │ │ │ │ │ ├── RegionOfInterest.h │ │ │ │ │ ├── RelativeHumidity.h │ │ │ │ │ ├── SetCameraInfo.h │ │ │ │ │ ├── Temperature.h │ │ │ │ │ └── TimeReference.h │ │ │ │ ├── std_msgs/ │ │ │ │ │ ├── Bool.h │ │ │ │ │ ├── Byte.h │ │ │ │ │ ├── ByteMultiArray.h │ │ │ │ │ ├── Char.h │ │ │ │ │ ├── ColorRGBA.h │ │ │ │ │ ├── Duration.h │ │ │ │ │ ├── Empty.h │ │ │ │ │ ├── Float32.h │ │ │ │ │ ├── Float32MultiArray.h │ │ │ │ │ ├── Float64.h │ │ │ │ │ ├── Float64MultiArray.h │ │ │ │ │ ├── Header.h │ │ │ │ │ ├── Int16.h │ │ │ │ │ ├── Int16MultiArray.h │ │ │ │ │ ├── Int32.h │ │ │ │ │ ├── Int32MultiArray.h │ │ │ │ │ ├── Int64.h │ │ │ │ │ ├── Int64MultiArray.h │ │ │ │ │ ├── Int8.h │ │ │ │ │ ├── Int8MultiArray.h │ │ │ │ │ ├── MultiArrayDimension.h │ │ │ │ │ ├── MultiArrayLayout.h │ │ │ │ │ ├── String.h │ │ │ │ │ ├── Time.h │ │ │ │ │ ├── UInt16.h │ │ │ │ │ ├── UInt16MultiArray.h │ │ │ │ │ ├── UInt32.h │ │ │ │ │ ├── UInt32MultiArray.h │ │ │ │ │ ├── UInt64.h │ │ │ │ │ ├── UInt64MultiArray.h │ │ │ │ │ ├── UInt8.h │ │ │ │ │ └── UInt8MultiArray.h │ │ │ │ ├── std_srvs/ │ │ │ │ │ ├── Empty.h │ │ │ │ │ ├── SetBool.h │ │ │ │ │ └── Trigger.h │ │ │ │ ├── tf/ │ │ │ │ │ ├── FrameGraph.h │ │ │ │ │ ├── tf.h │ │ │ │ │ ├── tfMessage.h │ │ │ │ │ └── transform_broadcaster.h │ │ │ │ ├── tf2_msgs/ │ │ │ │ │ ├── FrameGraph.h │ │ │ │ │ ├── LookupTransformAction.h │ │ │ │ │ ├── LookupTransformActionFeedback.h │ │ │ │ │ ├── LookupTransformActionGoal.h │ │ │ │ │ ├── LookupTransformActionResult.h │ │ │ │ │ ├── LookupTransformFeedback.h │ │ │ │ │ ├── LookupTransformGoal.h │ │ │ │ │ ├── LookupTransformResult.h │ │ │ │ │ ├── TF2Error.h │ │ │ │ │ └── TFMessage.h │ │ │ │ ├── time.cpp │ │ │ │ ├── trajectory_msgs/ │ │ │ │ │ ├── JointTrajectory.h │ │ │ │ │ ├── JointTrajectoryPoint.h │ │ │ │ │ ├── MultiDOFJointTrajectory.h │ │ │ │ │ └── MultiDOFJointTrajectoryPoint.h │ │ │ │ └── turtlebot3_msgs/ │ │ │ │ ├── SensorState.h │ │ │ │ ├── Sound.h │ │ │ │ └── VersionInfo.h │ │ │ ├── platform.txt │ │ │ ├── programmers.txt │ │ │ └── variants/ │ │ │ └── OpenCR/ │ │ │ ├── bsp/ │ │ │ │ └── opencr/ │ │ │ │ ├── bsp.c │ │ │ │ ├── bsp.h │ │ │ │ ├── include/ │ │ │ │ │ ├── arm_common_tables.h │ │ │ │ │ ├── arm_const_structs.h │ │ │ │ │ ├── arm_math.h │ │ │ │ │ ├── cmsis_armcc.h │ │ │ │ │ ├── cmsis_armcc_V6.h │ │ │ │ │ ├── cmsis_gcc.h │ │ │ │ │ ├── core_cm0.h │ │ │ │ │ ├── core_cm0plus.h │ │ │ │ │ ├── core_cm3.h │ │ │ │ │ ├── core_cm4.h │ │ │ │ │ ├── core_cm7.h │ │ │ │ │ ├── core_cmFunc.h │ │ │ │ │ ├── core_cmInstr.h │ │ │ │ │ ├── core_cmSimd.h │ │ │ │ │ ├── core_sc000.h │ │ │ │ │ └── core_sc300.h │ │ │ │ ├── ldscript/ │ │ │ │ │ └── opencr_flash.ld │ │ │ │ ├── startup/ │ │ │ │ │ └── startup_stm32f746xx.S │ │ │ │ ├── stm32f746xx.h │ │ │ │ ├── stm32f7xx.h │ │ │ │ ├── stm32f7xx_hal_conf.h │ │ │ │ ├── stm32f7xx_it.c │ │ │ │ ├── stm32f7xx_it.h │ │ │ │ ├── syscalls.c │ │ │ │ ├── system_clock.c │ │ │ │ ├── system_clock.h │ │ │ │ ├── system_stm32f7xx.c │ │ │ │ └── system_stm32f7xx.h │ │ │ ├── chip.h │ │ │ ├── hw/ │ │ │ │ ├── def.h │ │ │ │ ├── def_err.h │ │ │ │ ├── driver/ │ │ │ │ │ ├── delay.c │ │ │ │ │ ├── delay.h │ │ │ │ │ ├── dma_stream_handlers.c │ │ │ │ │ ├── dma_stream_handlers.h │ │ │ │ │ ├── drv_adc.c │ │ │ │ │ ├── drv_adc.h │ │ │ │ │ ├── drv_can.c │ │ │ │ │ ├── drv_can.h │ │ │ │ │ ├── drv_dxl.c │ │ │ │ │ ├── drv_dxl.h │ │ │ │ │ ├── drv_eeprom.c │ │ │ │ │ ├── drv_eeprom.h │ │ │ │ │ ├── drv_exti.c │ │ │ │ │ ├── drv_exti.h │ │ │ │ │ ├── drv_i2c.c │ │ │ │ │ ├── drv_i2c.h │ │ │ │ │ ├── drv_micros.c │ │ │ │ │ ├── drv_micros.h │ │ │ │ │ ├── drv_pwm.c │ │ │ │ │ ├── drv_pwm.h │ │ │ │ │ ├── drv_rtc.c │ │ │ │ │ ├── drv_rtc.h │ │ │ │ │ ├── drv_spi.c │ │ │ │ │ ├── drv_spi.h │ │ │ │ │ ├── drv_timer.c │ │ │ │ │ ├── drv_timer.h │ │ │ │ │ ├── drv_uart.c │ │ │ │ │ ├── drv_uart.h │ │ │ │ │ ├── flash.c │ │ │ │ │ ├── flash.h │ │ │ │ │ ├── ring.c │ │ │ │ │ ├── ring.h │ │ │ │ │ ├── vcp.c │ │ │ │ │ ├── vcp.h │ │ │ │ │ ├── wdg.c │ │ │ │ │ └── wdg.h │ │ │ │ ├── hw.c │ │ │ │ ├── hw.h │ │ │ │ └── usb_cdc/ │ │ │ │ ├── usbd_cdc.c │ │ │ │ ├── usbd_cdc.h │ │ │ │ ├── usbd_cdc_interface.c │ │ │ │ ├── usbd_cdc_interface.h │ │ │ │ ├── usbd_conf.c │ │ │ │ ├── usbd_conf.h │ │ │ │ ├── usbd_core.c │ │ │ │ ├── usbd_core.h │ │ │ │ ├── usbd_ctlreq.c │ │ │ │ ├── usbd_ctlreq.h │ │ │ │ ├── usbd_def.h │ │ │ │ ├── usbd_desc.c │ │ │ │ ├── usbd_desc.h │ │ │ │ ├── usbd_ioreq.c │ │ │ │ └── usbd_ioreq.h │ │ │ ├── lib/ │ │ │ │ └── STM32F7xx_HAL_Driver/ │ │ │ │ ├── Inc/ │ │ │ │ │ ├── Legacy/ │ │ │ │ │ │ └── stm32_hal_legacy.h │ │ │ │ │ ├── stm32f7xx_hal.h │ │ │ │ │ ├── stm32f7xx_hal_adc.h │ │ │ │ │ ├── stm32f7xx_hal_adc_ex.h │ │ │ │ │ ├── stm32f7xx_hal_can.h │ │ │ │ │ ├── stm32f7xx_hal_cec.h │ │ │ │ │ ├── stm32f7xx_hal_cortex.h │ │ │ │ │ ├── stm32f7xx_hal_crc.h │ │ │ │ │ ├── stm32f7xx_hal_crc_ex.h │ │ │ │ │ ├── stm32f7xx_hal_cryp.h │ │ │ │ │ ├── stm32f7xx_hal_cryp_ex.h │ │ │ │ │ ├── stm32f7xx_hal_dac.h │ │ │ │ │ ├── stm32f7xx_hal_dac_ex.h │ │ │ │ │ ├── stm32f7xx_hal_dcmi.h │ │ │ │ │ ├── stm32f7xx_hal_dcmi_ex.h │ │ │ │ │ ├── stm32f7xx_hal_def.h │ │ │ │ │ ├── stm32f7xx_hal_dma.h │ │ │ │ │ ├── stm32f7xx_hal_dma2d.h │ │ │ │ │ ├── stm32f7xx_hal_dma_ex.h │ │ │ │ │ ├── stm32f7xx_hal_eth.h │ │ │ │ │ ├── stm32f7xx_hal_flash.h │ │ │ │ │ ├── stm32f7xx_hal_flash_ex.h │ │ │ │ │ ├── stm32f7xx_hal_gpio.h │ │ │ │ │ ├── stm32f7xx_hal_gpio_ex.h │ │ │ │ │ ├── stm32f7xx_hal_hash.h │ │ │ │ │ ├── stm32f7xx_hal_hash_ex.h │ │ │ │ │ ├── stm32f7xx_hal_hcd.h │ │ │ │ │ ├── stm32f7xx_hal_i2c.h │ │ │ │ │ ├── stm32f7xx_hal_i2c_ex.h │ │ │ │ │ ├── stm32f7xx_hal_i2s.h │ │ │ │ │ ├── stm32f7xx_hal_irda.h │ │ │ │ │ ├── stm32f7xx_hal_irda_ex.h │ │ │ │ │ ├── stm32f7xx_hal_iwdg.h │ │ │ │ │ ├── stm32f7xx_hal_lptim.h │ │ │ │ │ ├── stm32f7xx_hal_ltdc.h │ │ │ │ │ ├── stm32f7xx_hal_nand.h │ │ │ │ │ ├── stm32f7xx_hal_nor.h │ │ │ │ │ ├── stm32f7xx_hal_pcd.h │ │ │ │ │ ├── stm32f7xx_hal_pcd_ex.h │ │ │ │ │ ├── stm32f7xx_hal_pwr.h │ │ │ │ │ ├── stm32f7xx_hal_pwr_ex.h │ │ │ │ │ ├── stm32f7xx_hal_qspi.h │ │ │ │ │ ├── stm32f7xx_hal_rcc.h │ │ │ │ │ ├── stm32f7xx_hal_rcc_ex.h │ │ │ │ │ ├── stm32f7xx_hal_rng.h │ │ │ │ │ ├── stm32f7xx_hal_rtc.h │ │ │ │ │ ├── stm32f7xx_hal_rtc_ex.h │ │ │ │ │ ├── stm32f7xx_hal_sai.h │ │ │ │ │ ├── stm32f7xx_hal_sai_ex.h │ │ │ │ │ ├── stm32f7xx_hal_sd.h │ │ │ │ │ ├── stm32f7xx_hal_sdram.h │ │ │ │ │ ├── stm32f7xx_hal_smartcard.h │ │ │ │ │ ├── stm32f7xx_hal_smartcard_ex.h │ │ │ │ │ ├── stm32f7xx_hal_spdifrx.h │ │ │ │ │ ├── stm32f7xx_hal_spi.h │ │ │ │ │ ├── stm32f7xx_hal_sram.h │ │ │ │ │ ├── stm32f7xx_hal_tim.h │ │ │ │ │ ├── stm32f7xx_hal_tim_ex.h │ │ │ │ │ ├── stm32f7xx_hal_uart.h │ │ │ │ │ ├── stm32f7xx_hal_uart_ex.h │ │ │ │ │ ├── stm32f7xx_hal_usart.h │ │ │ │ │ ├── stm32f7xx_hal_usart_ex.h │ │ │ │ │ ├── stm32f7xx_hal_wwdg.h │ │ │ │ │ ├── stm32f7xx_ll_fmc.h │ │ │ │ │ ├── stm32f7xx_ll_sdmmc.h │ │ │ │ │ └── stm32f7xx_ll_usb.h │ │ │ │ ├── Release_Notes.html │ │ │ │ └── Src/ │ │ │ │ ├── stm32f7xx_hal.c │ │ │ │ ├── stm32f7xx_hal_adc.c │ │ │ │ ├── stm32f7xx_hal_adc_ex.c │ │ │ │ ├── stm32f7xx_hal_can.c │ │ │ │ ├── stm32f7xx_hal_cec.c │ │ │ │ ├── stm32f7xx_hal_cortex.c │ │ │ │ ├── stm32f7xx_hal_crc.c │ │ │ │ ├── stm32f7xx_hal_crc_ex.c │ │ │ │ ├── stm32f7xx_hal_cryp.c │ │ │ │ ├── stm32f7xx_hal_cryp_ex.c │ │ │ │ ├── stm32f7xx_hal_dma.c │ │ │ │ ├── stm32f7xx_hal_dma2d.c │ │ │ │ ├── stm32f7xx_hal_dma_ex.c │ │ │ │ ├── stm32f7xx_hal_flash.c │ │ │ │ ├── stm32f7xx_hal_flash_ex.c │ │ │ │ ├── stm32f7xx_hal_gpio.c │ │ │ │ ├── stm32f7xx_hal_hash.c │ │ │ │ ├── stm32f7xx_hal_hash_ex.c │ │ │ │ ├── stm32f7xx_hal_hcd.c │ │ │ │ ├── stm32f7xx_hal_i2c.c │ │ │ │ ├── stm32f7xx_hal_i2c_ex.c │ │ │ │ ├── stm32f7xx_hal_i2s.c │ │ │ │ ├── stm32f7xx_hal_iwdg.c │ │ │ │ ├── stm32f7xx_hal_lptim.c │ │ │ │ ├── stm32f7xx_hal_ltdc.c │ │ │ │ ├── stm32f7xx_hal_pcd.c │ │ │ │ ├── stm32f7xx_hal_pcd_ex.c │ │ │ │ ├── stm32f7xx_hal_pwr.c │ │ │ │ ├── stm32f7xx_hal_pwr_ex.c │ │ │ │ ├── stm32f7xx_hal_rcc.c │ │ │ │ ├── stm32f7xx_hal_rcc_ex.c │ │ │ │ ├── stm32f7xx_hal_rng.c │ │ │ │ ├── stm32f7xx_hal_rtc.c │ │ │ │ ├── stm32f7xx_hal_rtc_ex.c │ │ │ │ ├── stm32f7xx_hal_sd.c │ │ │ │ ├── stm32f7xx_hal_spi.c │ │ │ │ ├── stm32f7xx_hal_tim.c │ │ │ │ ├── stm32f7xx_hal_uart.c │ │ │ │ ├── stm32f7xx_hal_usart.c │ │ │ │ ├── stm32f7xx_hal_wwdg.c │ │ │ │ ├── stm32f7xx_ll_sdmmc.c │ │ │ │ └── stm32f7xx_ll_usb.c │ │ │ ├── main.cpp │ │ │ ├── pins_arduino.h │ │ │ ├── variant.cpp │ │ │ └── variant.h │ │ └── tools/ │ │ └── opencr_tools_1.0.0/ │ │ ├── linux/ │ │ │ ├── dfu-util/ │ │ │ │ ├── dfu-prefix │ │ │ │ ├── dfu-suffix │ │ │ │ └── dfu-util │ │ │ └── opencr_ld │ │ ├── linux64/ │ │ │ ├── dfu-util/ │ │ │ │ ├── dfu-prefix │ │ │ │ ├── dfu-suffix │ │ │ │ └── dfu-util │ │ │ └── opencr_ld │ │ └── macosx/ │ │ ├── dfu-util/ │ │ │ ├── dfu-prefix │ │ │ ├── dfu-suffix │ │ │ └── dfu-util │ │ └── opencr_ld │ ├── opencr_develop/ │ │ ├── opencr_bootloader/ │ │ │ ├── .cproject │ │ │ ├── .gitignore │ │ │ ├── .project │ │ │ ├── Makefile │ │ │ ├── bin/ │ │ │ │ └── obj/ │ │ │ │ └── README │ │ │ ├── common/ │ │ │ │ ├── bsp/ │ │ │ │ │ └── opencr/ │ │ │ │ │ ├── bsp.c │ │ │ │ │ ├── bsp.h │ │ │ │ │ ├── button.c │ │ │ │ │ ├── button.h │ │ │ │ │ ├── cfg/ │ │ │ │ │ │ ├── startup_stm32f746xx.s │ │ │ │ │ │ ├── stm32f746xx.h │ │ │ │ │ │ ├── stm32f7xx.h │ │ │ │ │ │ ├── stm32f7xx_hal_conf.h │ │ │ │ │ │ ├── stm32f7xx_it.c │ │ │ │ │ │ ├── stm32f7xx_it.h │ │ │ │ │ │ ├── syscalls.c │ │ │ │ │ │ ├── system_clock.c │ │ │ │ │ │ ├── system_clock.h │ │ │ │ │ │ ├── system_stm32f7xx.c │ │ │ │ │ │ └── system_stm32f7xx.h │ │ │ │ │ ├── include/ │ │ │ │ │ │ ├── arm_common_tables.h │ │ │ │ │ │ ├── arm_const_structs.h │ │ │ │ │ │ ├── arm_math.h │ │ │ │ │ │ ├── cmsis_armcc.h │ │ │ │ │ │ ├── cmsis_armcc_V6.h │ │ │ │ │ │ ├── cmsis_gcc.h │ │ │ │ │ │ ├── core_cm0.h │ │ │ │ │ │ ├── core_cm0plus.h │ │ │ │ │ │ ├── core_cm3.h │ │ │ │ │ │ ├── core_cm4.h │ │ │ │ │ │ ├── core_cm7.h │ │ │ │ │ │ ├── core_cmFunc.h │ │ │ │ │ │ ├── core_cmInstr.h │ │ │ │ │ │ ├── core_cmSimd.h │ │ │ │ │ │ ├── core_sc000.h │ │ │ │ │ │ └── core_sc300.h │ │ │ │ │ ├── ld/ │ │ │ │ │ │ └── opencr_flash.ld │ │ │ │ │ ├── led.c │ │ │ │ │ ├── led.h │ │ │ │ │ ├── usbd_cdc.c │ │ │ │ │ ├── usbd_cdc.h │ │ │ │ │ ├── usbd_cdc_interface.c │ │ │ │ │ ├── usbd_cdc_interface.h │ │ │ │ │ ├── usbd_conf.c │ │ │ │ │ ├── usbd_conf.h │ │ │ │ │ ├── usbd_desc.c │ │ │ │ │ ├── usbd_desc.h │ │ │ │ │ ├── wdg.c │ │ │ │ │ └── wdg.h │ │ │ │ ├── hal/ │ │ │ │ │ ├── def.h │ │ │ │ │ ├── def_err.h │ │ │ │ │ ├── delay.c │ │ │ │ │ ├── delay.h │ │ │ │ │ ├── flash.c │ │ │ │ │ ├── flash.h │ │ │ │ │ ├── hal.c │ │ │ │ │ ├── hal.h │ │ │ │ │ ├── msg.c │ │ │ │ │ ├── msg.h │ │ │ │ │ ├── util.c │ │ │ │ │ ├── util.h │ │ │ │ │ ├── vcp.c │ │ │ │ │ └── vcp.h │ │ │ │ ├── lib/ │ │ │ │ │ ├── STM32F7xx_HAL_Driver/ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ ├── Legacy/ │ │ │ │ │ │ │ │ └── stm32_hal_legacy.h │ │ │ │ │ │ │ ├── stm32f7xx_hal.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_adc.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_adc_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_can.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_cec.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_conf_template.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_cortex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_crc.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_crc_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_cryp.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_cryp_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dac.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dac_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dcmi.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dcmi_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_def.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dfsdm.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dma.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dma2d.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dma_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_dsi.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_eth.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_flash.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_flash_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_gpio.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_gpio_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_hash.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_hash_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_hcd.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_i2c.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_i2c_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_i2s.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_irda.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_irda_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_iwdg.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_jpeg.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_lptim.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_ltdc.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_ltdc_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_mdios.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_nand.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_nor.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_pcd.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_pcd_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_pwr.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_pwr_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_qspi.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_rcc.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_rcc_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_rng.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_rtc.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_rtc_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_sai.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_sai_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_sd.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_sdram.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_smartcard.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_smartcard_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_spdifrx.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_spi.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_sram.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_tim.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_tim_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_uart.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_uart_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_usart.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_usart_ex.h │ │ │ │ │ │ │ ├── stm32f7xx_hal_wwdg.h │ │ │ │ │ │ │ ├── stm32f7xx_ll_fmc.h │ │ │ │ │ │ │ ├── stm32f7xx_ll_sdmmc.h │ │ │ │ │ │ │ └── stm32f7xx_ll_usb.h │ │ │ │ │ │ ├── Release_Notes.html │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ ├── stm32f7xx_hal.c │ │ │ │ │ │ ├── stm32f7xx_hal_adc.c │ │ │ │ │ │ ├── stm32f7xx_hal_adc_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_can.c │ │ │ │ │ │ ├── stm32f7xx_hal_cec.c │ │ │ │ │ │ ├── stm32f7xx_hal_cortex.c │ │ │ │ │ │ ├── stm32f7xx_hal_crc.c │ │ │ │ │ │ ├── stm32f7xx_hal_crc_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_cryp.c │ │ │ │ │ │ ├── stm32f7xx_hal_cryp_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_dac.c │ │ │ │ │ │ ├── stm32f7xx_hal_dac_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_dcmi.c │ │ │ │ │ │ ├── stm32f7xx_hal_dcmi_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_dfsdm.c │ │ │ │ │ │ ├── stm32f7xx_hal_dma.c │ │ │ │ │ │ ├── stm32f7xx_hal_dma2d.c │ │ │ │ │ │ ├── stm32f7xx_hal_dma_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_dsi.c │ │ │ │ │ │ ├── stm32f7xx_hal_eth.c │ │ │ │ │ │ ├── stm32f7xx_hal_flash.c │ │ │ │ │ │ ├── stm32f7xx_hal_flash_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_gpio.c │ │ │ │ │ │ ├── stm32f7xx_hal_hash.c │ │ │ │ │ │ ├── stm32f7xx_hal_hash_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_hcd.c │ │ │ │ │ │ ├── stm32f7xx_hal_i2c.c │ │ │ │ │ │ ├── stm32f7xx_hal_i2c_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_i2s.c │ │ │ │ │ │ ├── stm32f7xx_hal_irda.c │ │ │ │ │ │ ├── stm32f7xx_hal_iwdg.c │ │ │ │ │ │ ├── stm32f7xx_hal_jpeg.c │ │ │ │ │ │ ├── stm32f7xx_hal_lptim.c │ │ │ │ │ │ ├── stm32f7xx_hal_ltdc.c │ │ │ │ │ │ ├── stm32f7xx_hal_ltdc_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_mdios.c │ │ │ │ │ │ ├── stm32f7xx_hal_msp_template.c │ │ │ │ │ │ ├── stm32f7xx_hal_nand.c │ │ │ │ │ │ ├── stm32f7xx_hal_nor.c │ │ │ │ │ │ ├── stm32f7xx_hal_pcd.c │ │ │ │ │ │ ├── stm32f7xx_hal_pcd_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_pwr.c │ │ │ │ │ │ ├── stm32f7xx_hal_pwr_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_qspi.c │ │ │ │ │ │ ├── stm32f7xx_hal_rcc.c │ │ │ │ │ │ ├── stm32f7xx_hal_rcc_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_rng.c │ │ │ │ │ │ ├── stm32f7xx_hal_rtc.c │ │ │ │ │ │ ├── stm32f7xx_hal_rtc_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_sai.c │ │ │ │ │ │ ├── stm32f7xx_hal_sai_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_sd.c │ │ │ │ │ │ ├── stm32f7xx_hal_sdram.c │ │ │ │ │ │ ├── stm32f7xx_hal_smartcard.c │ │ │ │ │ │ ├── stm32f7xx_hal_smartcard_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_spdifrx.c │ │ │ │ │ │ ├── stm32f7xx_hal_spi.c │ │ │ │ │ │ ├── stm32f7xx_hal_sram.c │ │ │ │ │ │ ├── stm32f7xx_hal_tim.c │ │ │ │ │ │ ├── stm32f7xx_hal_tim_ex.c │ │ │ │ │ │ ├── stm32f7xx_hal_timebase_tim_template.c │ │ │ │ │ │ ├── stm32f7xx_hal_uart.c │ │ │ │ │ │ ├── stm32f7xx_hal_usart.c │ │ │ │ │ │ ├── stm32f7xx_hal_wwdg.c │ │ │ │ │ │ ├── stm32f7xx_ll_fmc.c │ │ │ │ │ │ ├── stm32f7xx_ll_sdmmc.c │ │ │ │ │ │ └── stm32f7xx_ll_usb.c │ │ │ │ │ └── STM32_USB_Device_Library/ │ │ │ │ │ ├── Class/ │ │ │ │ │ │ ├── AUDIO/ │ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ │ ├── usbd_audio.h │ │ │ │ │ │ │ │ └── usbd_audio_if_template.h │ │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ │ ├── usbd_audio.c │ │ │ │ │ │ │ └── usbd_audio_if_template.c │ │ │ │ │ │ ├── CDC/ │ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ │ ├── usbd_cdc.h │ │ │ │ │ │ │ │ └── usbd_cdc_if_template.h │ │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ │ └── usbd_cdc.c │ │ │ │ │ │ ├── CustomHID/ │ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ │ ├── usbd_customhid.h │ │ │ │ │ │ │ │ └── usbd_customhid_if_template.h │ │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ │ ├── usbd_customhid.c │ │ │ │ │ │ │ └── usbd_customhid_if_template.c │ │ │ │ │ │ ├── DFU/ │ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ │ ├── usbd_dfu.h │ │ │ │ │ │ │ │ └── usbd_dfu_media_template.h │ │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ │ ├── usbd_dfu.c │ │ │ │ │ │ │ └── usbd_dfu_media_template.c │ │ │ │ │ │ ├── HID/ │ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ │ └── usbd_hid.h │ │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ │ └── usbd_hid.c │ │ │ │ │ │ ├── MSC/ │ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ │ ├── usbd_msc.h │ │ │ │ │ │ │ │ ├── usbd_msc_bot.h │ │ │ │ │ │ │ │ ├── usbd_msc_data.h │ │ │ │ │ │ │ │ ├── usbd_msc_scsi.h │ │ │ │ │ │ │ │ └── usbd_msc_storage_template.h │ │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ │ ├── usbd_msc.c │ │ │ │ │ │ │ ├── usbd_msc_bot.c │ │ │ │ │ │ │ ├── usbd_msc_data.c │ │ │ │ │ │ │ ├── usbd_msc_scsi.c │ │ │ │ │ │ │ └── usbd_msc_storage_template.c │ │ │ │ │ │ └── Template/ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ └── usbd_template.h │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ └── usbd_template.c │ │ │ │ │ ├── Core/ │ │ │ │ │ │ ├── Inc/ │ │ │ │ │ │ │ ├── usbd_conf_template.h │ │ │ │ │ │ │ ├── usbd_core.h │ │ │ │ │ │ │ ├── usbd_ctlreq.h │ │ │ │ │ │ │ ├── usbd_def.h │ │ │ │ │ │ │ └── usbd_ioreq.h │ │ │ │ │ │ └── Src/ │ │ │ │ │ │ ├── usbd_core.c │ │ │ │ │ │ ├── usbd_ctlreq.c │ │ │ │ │ │ └── usbd_ioreq.c │ │ │ │ │ └── Release_Notes.html │ │ │ │ └── msg/ │ │ │ │ ├── mavlink/ │ │ │ │ │ ├── checksum.h │ │ │ │ │ ├── mavlink_conversions.h │ │ │ │ │ ├── mavlink_helpers.h │ │ │ │ │ ├── mavlink_types.h │ │ │ │ │ ├── opencr_msg/ │ │ │ │ │ │ ├── mavlink.h │ │ │ │ │ │ ├── mavlink_msg_ack.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_erase.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_read_block.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_read_packet.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_verify.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_begin.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_block.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_end.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_packet.h │ │ │ │ │ │ ├── mavlink_msg_jump_to_fw.h │ │ │ │ │ │ ├── mavlink_msg_read_board_name.h │ │ │ │ │ │ ├── mavlink_msg_read_tag.h │ │ │ │ │ │ ├── mavlink_msg_read_version.h │ │ │ │ │ │ ├── opencr_msg.h │ │ │ │ │ │ ├── testsuite.h │ │ │ │ │ │ └── version.h │ │ │ │ │ └── protocol.h │ │ │ │ └── xml/ │ │ │ │ └── opencr_msg │ │ │ ├── main.c │ │ │ ├── main.h │ │ │ ├── opencr_flash.cfg │ │ │ ├── opencr_openocd.cfg │ │ │ └── src/ │ │ │ ├── cmd.c │ │ │ ├── cmd.h │ │ │ ├── crc.c │ │ │ └── crc.h │ │ ├── opencr_ld/ │ │ │ ├── .cproject │ │ │ ├── .gitignore │ │ │ ├── .project │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── gcc_win/ │ │ │ │ ├── .cproject │ │ │ │ ├── .gitignore │ │ │ │ └── .project │ │ │ ├── images/ │ │ │ │ └── linux_180529/ │ │ │ │ └── opencr_ld.tar.bz2 │ │ │ ├── main.c │ │ │ ├── msg/ │ │ │ │ ├── def.h │ │ │ │ ├── def_err.h │ │ │ │ ├── mavlink/ │ │ │ │ │ ├── checksum.h │ │ │ │ │ ├── mavlink_conversions.h │ │ │ │ │ ├── mavlink_helpers.h │ │ │ │ │ ├── mavlink_types.h │ │ │ │ │ ├── opencr_msg/ │ │ │ │ │ │ ├── mavlink.h │ │ │ │ │ │ ├── mavlink_msg_ack.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_erase.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_read_block.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_read_packet.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_verify.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_begin.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_block.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_end.h │ │ │ │ │ │ ├── mavlink_msg_flash_fw_write_packet.h │ │ │ │ │ │ ├── mavlink_msg_jump_to_fw.h │ │ │ │ │ │ ├── mavlink_msg_read_board_name.h │ │ │ │ │ │ ├── mavlink_msg_read_tag.h │ │ │ │ │ │ ├── mavlink_msg_read_version.h │ │ │ │ │ │ ├── opencr_msg.h │ │ │ │ │ │ ├── testsuite.h │ │ │ │ │ │ └── version.h │ │ │ │ │ └── protocol.h │ │ │ │ ├── msg.c │ │ │ │ ├── msg.h │ │ │ │ └── xml/ │ │ │ │ └── opencr_msg │ │ │ ├── opencr_ld.c │ │ │ ├── opencr_ld.h │ │ │ ├── qt_win/ │ │ │ │ └── opencr_ld_win/ │ │ │ │ └── opencr_ld/ │ │ │ │ ├── main.c │ │ │ │ └── opencr_ld.pro │ │ │ ├── serial.h │ │ │ ├── serial_posix.c │ │ │ ├── serial_win32.c │ │ │ └── type.h │ │ └── opencr_ld_shell/ │ │ ├── .cproject │ │ ├── .gitignore │ │ ├── .project │ │ ├── Makefile │ │ ├── README.md │ │ ├── install_opencr.sh │ │ ├── main.c │ │ ├── msg/ │ │ │ ├── def.h │ │ │ ├── def_err.h │ │ │ ├── mavlink/ │ │ │ │ ├── checksum.h │ │ │ │ ├── mavlink_conversions.h │ │ │ │ ├── mavlink_helpers.h │ │ │ │ ├── mavlink_types.h │ │ │ │ ├── opencr_msg/ │ │ │ │ │ ├── mavlink.h │ │ │ │ │ ├── mavlink_msg_ack.h │ │ │ │ │ ├── mavlink_msg_flash_fw_erase.h │ │ │ │ │ ├── mavlink_msg_flash_fw_read_block.h │ │ │ │ │ ├── mavlink_msg_flash_fw_read_packet.h │ │ │ │ │ ├── mavlink_msg_flash_fw_verify.h │ │ │ │ │ ├── mavlink_msg_flash_fw_write_begin.h │ │ │ │ │ ├── mavlink_msg_flash_fw_write_block.h │ │ │ │ │ ├── mavlink_msg_flash_fw_write_end.h │ │ │ │ │ ├── mavlink_msg_flash_fw_write_packet.h │ │ │ │ │ ├── mavlink_msg_jump_to_fw.h │ │ │ │ │ ├── mavlink_msg_read_board_name.h │ │ │ │ │ ├── mavlink_msg_read_tag.h │ │ │ │ │ ├── mavlink_msg_read_version.h │ │ │ │ │ ├── opencr_msg.h │ │ │ │ │ ├── testsuite.h │ │ │ │ │ └── version.h │ │ │ │ └── protocol.h │ │ │ ├── msg.c │ │ │ ├── msg.h │ │ │ └── xml/ │ │ │ └── opencr_msg │ │ ├── opencr_ld.c │ │ ├── opencr_ld.h │ │ ├── opencr_ld_shell_arm │ │ ├── opencr_ld_shell_x86 │ │ ├── qt_win/ │ │ │ └── opencr_ld_win/ │ │ │ └── opencr_ld/ │ │ │ ├── .gitignore │ │ │ ├── main.c │ │ │ ├── opencr_ld.pro │ │ │ └── opencr_ld.pro.user │ │ ├── serial.h │ │ ├── serial_posix.c │ │ ├── serial_win32.c │ │ ├── type.h │ │ └── update.sh │ └── opencr_release/ │ └── package_opencr_index.json └── install.sh
Showing preview only (1,020K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (10056 symbols across 1042 files)
FILE: arduino/opencr_arduino/opencr/cores/arduino/Client.h
function class (line 26) | class Client : public Stream {
FILE: arduino/opencr_arduino/opencr/cores/arduino/HardwareSerial.h
function class (line 26) | class HardwareSerial : public Stream
FILE: arduino/opencr_arduino/opencr/cores/arduino/HardwareTimer.h
function class (line 37) | class HardwareTimer {
FILE: arduino/opencr_arduino/opencr/cores/arduino/IPAddress.cpp
function IPAddress (line 86) | IPAddress& IPAddress::operator=(const uint8_t *address)
function IPAddress (line 92) | IPAddress& IPAddress::operator=(uint32_t address)
FILE: arduino/opencr_arduino/opencr/cores/arduino/IPAddress.h
function class (line 29) | class IPAddress : public Printable {
FILE: arduino/opencr_arduino/opencr/cores/arduino/Print.h
function class (line 35) | class Print
function getWriteError (line 46) | int getWriteError() { return write_error; }
function clearWriteError (line 47) | void clearWriteError() { setWriteError(0); }
function write (line 50) | size_t write(const char *str) {
function write (line 55) | size_t write(const char *buffer, size_t size) {
FILE: arduino/opencr_arduino/opencr/cores/arduino/Printable.h
function class (line 33) | class Printable
FILE: arduino/opencr_arduino/opencr/cores/arduino/RingBuffer.h
function class (line 30) | class RingBuffer
FILE: arduino/opencr_arduino/opencr/cores/arduino/Server.h
function class (line 25) | class Server : public Print {
FILE: arduino/opencr_arduino/opencr/cores/arduino/Stream.cpp
function String (line 230) | String Stream::readString()
function String (line 242) | String Stream::readStringUntil(char terminator)
type Stream::MultiTarget (line 254) | struct Stream::MultiTarget
type MultiTarget (line 257) | struct MultiTarget
type MultiTarget (line 267) | struct MultiTarget
FILE: arduino/opencr_arduino/opencr/cores/arduino/Stream.h
function class (line 38) | class Stream : public Print
FILE: arduino/opencr_arduino/opencr/cores/arduino/Tone.cpp
function toneBegin (line 59) | static void toneBegin(uint8_t _pin)
function toneEnd (line 67) | static void toneEnd(void)
function tone (line 77) | void tone(uint8_t _pin, unsigned int frequency, unsigned long duration)
function noTone (line 111) | void noTone(uint8_t _pin)
function tone_isr (line 118) | void tone_isr( void )
FILE: arduino/opencr_arduino/opencr/cores/arduino/UARTClass.h
function class (line 34) | class UARTClass : public HardwareSerial
FILE: arduino/opencr_arduino/opencr/cores/arduino/USBSerial.h
function class (line 41) | class USBSerial : public Stream {
FILE: arduino/opencr_arduino/opencr/cores/arduino/Udp.h
function class (line 41) | class UDP : public Stream {
FILE: arduino/opencr_arduino/opencr/cores/arduino/WCharacter.h
function boolean (line 52) | inline boolean isAlphaNumeric(int c)
function boolean (line 60) | inline boolean isAlpha(int c)
function boolean (line 68) | inline boolean isAscii(int c)
function boolean (line 76) | inline boolean isWhitespace(int c)
function boolean (line 83) | inline boolean isControl(int c)
function boolean (line 90) | inline boolean isDigit(int c)
function boolean (line 97) | inline boolean isGraph(int c)
function boolean (line 104) | inline boolean isLowerCase(int c)
function boolean (line 111) | inline boolean isPrintable(int c)
function boolean (line 119) | inline boolean isPunct(int c)
function boolean (line 128) | inline boolean isSpace(int c)
function boolean (line 135) | inline boolean isUpperCase(int c)
function boolean (line 143) | inline boolean isHexadecimalDigit(int c)
function toAscii (line 151) | inline int toAscii(int c)
function toLowerCase (line 164) | inline int toLowerCase(int c)
function toUpperCase (line 171) | inline int toUpperCase(int c)
FILE: arduino/opencr_arduino/opencr/cores/arduino/WInterrupts.c
function attachInterrupt (line 36) | void attachInterrupt( uint32_t pin, voidFuncPtr callback, uint32_t ulMode )
function detachInterrupt (line 44) | void detachInterrupt( uint32_t pin )
FILE: arduino/opencr_arduino/opencr/cores/arduino/WMath.cpp
function randomSeed (line 25) | extern void randomSeed( uint32_t dwSeed )
function random (line 33) | extern long random( long howbig )
function random (line 43) | extern long random( long howsmall, long howbig )
function map (line 55) | extern long map(long x, long in_min, long in_max, long out_min, long out...
function makeWord (line 60) | extern uint16_t makeWord( uint16_t w )
function makeWord (line 65) | extern uint16_t makeWord( uint8_t h, uint8_t l )
FILE: arduino/opencr_arduino/opencr/cores/arduino/WString.cpp
function String (line 172) | String & String::copy(const char *cstr, unsigned int length)
function String (line 183) | String & String::copy(const __FlashStringHelper *pstr, unsigned int length)
function String (line 216) | String & String::operator = (const String &rhs)
function String (line 227) | String & String::operator = (String &&rval)
function String (line 233) | String & String::operator = (StringSumHelper &&rval)
function String (line 240) | String & String::operator = (const char *cstr)
function String (line 248) | String & String::operator = (const __FlashStringHelper *pstr)
function StringSumHelper (line 355) | StringSumHelper & operator + (const StringSumHelper &lhs, const String &...
function StringSumHelper (line 362) | StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
function StringSumHelper (line 369) | StringSumHelper & operator + (const StringSumHelper &lhs, char c)
function StringSumHelper (line 376) | StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char ...
function StringSumHelper (line 383) | StringSumHelper & operator + (const StringSumHelper &lhs, int num)
function StringSumHelper (line 390) | StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
function StringSumHelper (line 397) | StringSumHelper & operator + (const StringSumHelper &lhs, long num)
function StringSumHelper (line 404) | StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long ...
function StringSumHelper (line 411) | StringSumHelper & operator + (const StringSumHelper &lhs, float num)
function StringSumHelper (line 418) | StringSumHelper & operator + (const StringSumHelper &lhs, double num)
function StringSumHelper (line 425) | StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashS...
function String (line 617) | String String::substring(unsigned int left, unsigned int right) const
FILE: arduino/opencr_arduino/opencr/cores/arduino/WString.h
function class (line 45) | class String
function operator (line 143) | unsigned char operator == (const String &rhs) const {return equals(rhs);}
function operator (line 144) | unsigned char operator == (const char *cstr) const {return equals(cstr);}
function operator (line 145) | unsigned char operator != (const String &rhs) const {return !equals(rhs);}
function operator (line 146) | unsigned char operator != (const char *cstr) const {return !equals(cstr);}
function String (line 175) | String substring( unsigned int beginIndex ) const { return substring(beg...
function class (line 209) | class StringSumHelper : public String
FILE: arduino/opencr_arduino/opencr/cores/arduino/avr/pgmspace.h
type prog_void (line 12) | typedef void prog_void;
type prog_char (line 13) | typedef char prog_char;
type prog_uchar (line 14) | typedef unsigned char prog_uchar;
type prog_int8_t (line 15) | typedef int8_t prog_int8_t;
type prog_uint8_t (line 16) | typedef uint8_t prog_uint8_t;
type prog_int16_t (line 17) | typedef int16_t prog_int16_t;
type prog_uint16_t (line 18) | typedef uint16_t prog_uint16_t;
type prog_int32_t (line 19) | typedef int32_t prog_int32_t;
type prog_uint32_t (line 20) | typedef uint32_t prog_uint32_t;
FILE: arduino/opencr_arduino/opencr/cores/arduino/digitalWriteFast.h
function digitalWriteFast (line 33) | static inline void digitalWriteFast(uint8_t pin, uint8_t val)
function digitalReadFast (line 52) | static inline int digitalReadFast(uint8_t pin)
FILE: arduino/opencr_arduino/opencr/cores/arduino/syscalls.h
type stat (line 47) | struct stat
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring.c
function micros (line 40) | uint32_t micros( void )
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring.h
function delayMicroseconds (line 69) | static inline void delayMicroseconds(uint32_t usec){
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_analog.c
function analogReadResolution (line 28) | void analogReadResolution(int res) {
function analogWriteResolution (line 33) | void analogWriteResolution(int res) {
function mapResolution (line 37) | static inline uint32_t mapResolution(uint32_t value, uint32_t from, uint...
function analogReference (line 46) | void analogReference(uint8_t mode){
function analogRead (line 50) | uint32_t analogRead( uint32_t ulPin ){
function analogWrite (line 84) | void analogWrite( uint32_t ulPin, uint32_t ulValue ){
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_analog.h
type eAnalogReference (line 40) | typedef enum _eAnalogReference
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_constants.h
type BitOrder (line 49) | enum BitOrder {
type word (line 94) | typedef unsigned int word;
type boolean (line 98) | typedef bool boolean ;
type byte (line 99) | typedef uint8_t byte ;
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_digital.c
function pinMode (line 85) | extern void pinMode( uint32_t ulPin, uint32_t ulMode )
function digitalWrite (line 137) | extern void digitalWrite( uint32_t ulPin, uint32_t ulVal )
function digitalRead (line 161) | extern int digitalRead( uint32_t ulPin )
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_pulse.c
function pulseIn (line 29) | uint32_t pulseIn( uint32_t ulPin, uint32_t state, uint32_t timeout )
FILE: arduino/opencr_arduino/opencr/cores/arduino/wiring_shift.c
function shiftIn (line 25) | uint32_t shiftIn( uint32_t ulDataPin, uint32_t ulClockPin, uint32_t ulBi...
function shiftOut (line 49) | void shiftOut( uint32_t ulDataPin, uint32_t ulClockPin, uint32_t ulBitOr...
FILE: arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_GFX.cpp
function boolean (line 1119) | boolean Adafruit_GFX_Button::contains(int16_t x, int16_t y) {
function boolean (line 1129) | boolean Adafruit_GFX_Button::isPressed() { return currstate; }
function boolean (line 1130) | boolean Adafruit_GFX_Button::justPressed() { return (currstate && !lasts...
function boolean (line 1131) | boolean Adafruit_GFX_Button::justReleased() { return (!currstate && last...
FILE: arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_GFX.h
function class (line 12) | class Adafruit_GFX : public Print {
function class (line 145) | class Adafruit_GFX_Button {
function class (line 176) | class GFXcanvas1 : public Adafruit_GFX {
function class (line 187) | class GFXcanvas8 : public Adafruit_GFX {
function class (line 200) | class GFXcanvas16 : public Adafruit_GFX {
FILE: arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_SPITFT.h
type uint32 (line 17) | typedef volatile uint32 RwReg;
type RwReg (line 20) | typedef volatile uint32_t RwReg;
function class (line 23) | class Adafruit_SPITFT : public Adafruit_GFX {
FILE: arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_SPITFT_Macros.h
function _avr_spi_read (line 91) | static inline uint8_t _avr_spi_read(void) {
FILE: arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/fontconvert/fontconvert.c
function enbit (line 30) | void enbit(uint8_t value) {
function main (line 49) | int main(int argc, char *argv[]) {
FILE: arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/gfxfont.h
type GFXglyph (line 10) | typedef struct { // Data stored PER GLYPH
type GFXfont (line 17) | typedef struct { // Data stored for FONT AS A WHOLE:
FILE: arduino/opencr_arduino/opencr/libraries/CAN/CAN.h
type can_message_t (line 17) | typedef struct can_message
function class (line 25) | class CANClass
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/group_bulk_read.h
function namespace (line 31) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/group_bulk_write.h
function namespace (line 31) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/group_sync_read.h
function namespace (line 31) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/group_sync_write.h
function namespace (line 31) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/packet_handler.h
function namespace (line 76) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler.h
function namespace (line 50) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler_arduino.h
function namespace (line 31) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler_linux.h
function namespace (line 28) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler_mac.h
function namespace (line 28) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler_windows.h
function namespace (line 29) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/protocol1_packet_handler.h
function namespace (line 28) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/protocol2_packet_handler.h
function namespace (line 28) | namespace dynamixel
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/packet_handler.cpp
function PacketHandler (line 40) | PacketHandler *PacketHandler::getPacketHandler(float protocol_version)
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/port_handler.cpp
function PortHandler (line 36) | PortHandler *PortHandler::getPortHandler(const char *port_name)
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/port_handler_linux.cpp
type timespec (line 164) | struct timespec
type termios (line 182) | struct termios
type serial_struct (line 211) | struct serial_struct
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/port_handler_mac.cpp
type timespec (line 152) | struct timespec
type termios (line 180) | struct termios
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/include/dynamixel_workbench_toolbox/dynamixel_driver.h
type SyncWriteHandler (line 36) | typedef struct
type SyncReadHandler (line 42) | typedef struct
type BulkParameter (line 48) | typedef struct
type ErrorFromSDK (line 55) | typedef struct
function class (line 63) | class DynamixelDriver
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/include/dynamixel_workbench_toolbox/dynamixel_item.h
type ControlItem (line 111) | typedef struct
type ModelInfo (line 119) | typedef struct
function namespace (line 132) | namespace DynamixelItem
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/include/dynamixel_workbench_toolbox/dynamixel_tool.h
function class (line 27) | class DynamixelTool
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/include/dynamixel_workbench_toolbox/dynamixel_workbench.h
function class (line 24) | class DynamixelWorkbench : public DynamixelDriver
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/src/dynamixel_workbench_toolbox/dynamixel_driver.cpp
function ControlItem (line 202) | const ControlItem* DynamixelDriver::getControlTable(uint8_t id, const ch...
function ControlItem (line 210) | const ControlItem* DynamixelDriver::getItemInfo(uint8_t id, const char *...
function ModelInfo (line 232) | const ModelInfo* DynamixelDriver::getModelInfo(uint8_t id, const char **...
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/src/dynamixel_workbench_toolbox/dynamixel_item.cpp
function ControlItem (line 1259) | const ControlItem *DynamixelItem::getControlTable(uint16_t model_number)
function ModelInfo (line 1372) | const ModelInfo *DynamixelItem::getModelInfo(uint16_t model_number)
FILE: arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/src/dynamixel_workbench_toolbox/dynamixel_tool.cpp
function ControlItem (line 298) | const ControlItem *DynamixelTool::getControlItem(const char *item_name, ...
function ControlItem (line 318) | const ControlItem *DynamixelTool::getControlTable(void)
function ModelInfo (line 323) | const ModelInfo *DynamixelTool::getModelInfo(void)
FILE: arduino/opencr_arduino/opencr/libraries/EEPROM/src/EEPROM.h
type EERef (line 35) | struct EERef{
function operator (line 70) | uint8_t operator-- (int){
type EEPtr (line 86) | struct EEPtr{
function EERef (line 96) | EERef operator*() { return index; }
function EEPtr (line 101) | EEPtr operator++ (int) { return index++; }
function EEPtr (line 102) | EEPtr operator-- (int) { return index--; }
function read (line 115) | struct EEPROMClass{
function write (line 120) | void write( int idx, uint8_t val ) { (EERef( idx )) = val; }
function update (line 121) | void update( int idx, uint8_t val ) { EERef( idx ).update( val ); }
function EEPtr (line 124) | EEPtr begin() { return 0x00; }
function EEPtr (line 125) | EEPtr end() { return length(); }
function length (line 126) | uint16_t length() { return drv_eeprom_get_length(); }
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen.h
function namespace (line 29) | namespace std {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Cholesky/LDLT.h
function namespace (line 16) | namespace Eigen {
function namespace (line 287) | namespace internal {
function Upper (line 451) | struct ldlt_inplace<Upper>
type TriangularView (line 471) | typedef const TriangularView<const typename
function MatrixL (line 472) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 473) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
type TriangularView (line 479) | typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
function MatrixL (line 480) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 481) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
type typename (line 532) | typedef typename TranspositionType::StorageIndex IndexType;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Cholesky/LLT.h
function namespace (line 13) | namespace Eigen {
function namespace (line 224) | namespace internal {
type typename (line 368) | typedef typename NumTraits<Scalar>::Real RealScalar;
type TriangularView (line 393) | typedef const TriangularView<const typename
function MatrixL (line 394) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 395) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
function inplace_decomposition (line 396) | static bool inplace_decomposition(MatrixType& m)
type TriangularView (line 403) | typedef const TriangularView<const MatrixType, Upper> MatrixU;
function MatrixL (line 404) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 405) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
function inplace_decomposition (line 406) | static bool inplace_decomposition(MatrixType& m)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Cholesky/LLT_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/CholmodSupport/CholmodSupport.h
function namespace (line 13) | namespace Eigen {
function cholmod_sparse (line 105) | cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>...
function cholmod_sparse (line 112) | cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>...
type typename (line 137) | typedef typename Derived::Scalar Scalar;
type CholmodMode (line 162) | enum CholmodMode {
type typename (line 182) | typedef typename MatrixType::Scalar Scalar;
type typename (line 183) | typedef typename MatrixType::RealScalar RealScalar;
type MatrixType (line 184) | typedef MatrixType CholMatrixType;
type typename (line 185) | typedef typename MatrixType::StorageIndex StorageIndex;
function StorageIndex (line 217) | inline StorageIndex cols() const { return internal::convert_index<Storag...
function analyzePattern (line 245) | void analyzePattern(const MatrixType& matrix)
function factorize (line 267) | void factorize(const MatrixType& matrix)
function Scalar (line 348) | Scalar determinant() const
function Base (line 445) | CholmodSimplicialLLT(const MatrixType& matrix) : Base()
function Base (line 496) | CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
function Base (line 545) | CholmodSupernodalLLT(const MatrixType& matrix) : Base()
function Base (line 596) | CholmodDecomposition(const MatrixType& matrix) : Base()
function setMode (line 604) | void setMode(CholmodMode mode)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Array.h
function namespace (line 13) | namespace Eigen {
function enum (line 51) | EIGEN_DENSE_PUBLIC_INTERFACE(Array)
function EIGEN_DEVICE_FUNC (line 141) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 170) | EIGEN_STRONG_INLINE explicit Array(const T& x)
function EIGEN_STRONG_INLINE (line 178) | EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
function Base (line 230) | Array(const Array& other)
function EIGEN_STRONG_INLINE (line 237) | EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other)
type internal (line 251) | struct internal
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/ArrayBase.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/ArrayWrapper.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Assign.h
function namespace (line 15) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/AssignEvaluator.h
function namespace (line 15) | namespace Eigen {
type typename (line 347) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type unaligned_dense_assignment_loop (line 372) | struct unaligned_dense_assignment_loop
type typename (line 400) | typedef typename Kernel::Scalar Scalar;
type typename (line 401) | typedef typename Kernel::PacketType PacketType;
type typename (line 427) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 428) | typedef typename Kernel::PacketType PacketType;
function run (line 451) | void run(Kernel &kernel)
type typename (line 467) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 477) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 478) | typedef typename Kernel::AssignmentTraits Traits;
type typename (line 506) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
function run (line 518) | static inline void run(Kernel &kernel)
function run (line 566) | static inline void run(Kernel &kernel)
type typename (line 600) | typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
type SrcEvaluatorTypeT (line 604) | typedef SrcEvaluatorTypeT SrcEvaluatorType;
type typename (line 605) | typedef typename DstEvaluatorType::Scalar Scalar;
type copy_using_evaluator_traits (line 606) | typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT...
type typename (line 607) | typedef typename AssignmentTraits::PacketType PacketType;
function EIGEN_DEVICE_FUNC (line 625) | EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() { return m_dst; }
function assignCoeff (line 629) | void assignCoeff(Index row, Index col)
function assignCoeff (line 635) | void assignCoeff(Index index)
function assignCoeffByOuterInner (line 641) | void assignCoeffByOuterInner(Index outer, Index inner)
function assignPacket (line 650) | void assignPacket(Index row, Index col)
function assignPacket (line 656) | void assignPacket(Index index)
function assignPacketByOuterInner (line 662) | void assignPacketByOuterInner(Index outer, Index inner)
function Index (line 669) | Index rowIndexByOuterInner(Index outer, Index inner)
function Index (line 678) | Index colIndexByOuterInner(Index outer, Index inner)
function EIGEN_DEVICE_FUNC (line 687) | EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
type evaluator (line 707) | typedef evaluator<DstXprType> DstEvaluatorType;
type evaluator (line 708) | typedef evaluator<SrcXprType> SrcEvaluatorType;
type generic_dense_assignment_kernel (line 721) | typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorTyp...
function call_dense_assignment_loop (line 728) | void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
type Dense2Dense (line 743) | struct Dense2Dense {}
type EigenBase2EigenBase (line 744) | struct EigenBase2EigenBase {}
type EigenBase2EigenBase (line 746) | typedef EigenBase2EigenBase Kind;
type AssignmentKind (line 747) | struct AssignmentKind
type Dense2Dense (line 747) | typedef Dense2Dense Kind;
function call_assignment (line 763) | void call_assignment(Dst& dst, const Src& src)
function call_assignment (line 769) | void call_assignment(const Dst& dst, const Src& src)
function call_assignment_no_alias (line 802) | void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
function call_assignment_no_alias (line 823) | void call_assignment_no_alias(Dst& dst, const Src& src)
function call_assignment_no_alias_no_transpose (line 830) | void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, con...
function call_assignment_no_alias_no_transpose (line 841) | void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
type Assignment (line 871) | struct Assignment
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/BandMatrix.h
function namespace (line 13) | namespace Eigen {
type typename (line 103) | typedef typename internal::conditional<Conjugate,
function typename (line 115) | const typename DiagonalIntReturnType<N>::Type diagonal() const
function DenseMatrixType (line 145) | DenseMatrixType toDenseMatrix() const
type Dense (line 181) | typedef Dense StorageKind;
type Eigen (line 182) | typedef Eigen::Index StorageIndex;
type Matrix (line 195) | typedef Matrix<Scalar,DataRowsAtCompileTime,ColsAtCompileTime,Options
type typename (line 203) | typedef typename internal::traits<BandMatrix>::Scalar Scalar;
type typename (line 204) | typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
type typename (line 205) | typedef typename internal::traits<BandMatrix>::CoefficientsType Coeffici...
function CoefficientsType (line 226) | inline CoefficientsType& coeffs() { return m_coeffs; }
type typename (line 243) | typedef typename _CoefficientsType::StorageKind StorageKind;
type typename (line 244) | typedef typename _CoefficientsType::StorageIndex StorageIndex;
type _CoefficientsType (line 257) | typedef _CoefficientsType CoefficientsType;
type typename (line 266) | typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType C...
type typename (line 267) | typedef typename internal::traits<BandMatrixWrapper>::StorageIndex Stora...
type typename (line 315) | typedef typename Base::StorageIndex StorageIndex;
type BandShape (line 331) | struct BandShape {}
type AssignmentKind (line 347) | struct AssignmentKind
type EigenBase2EigenBase (line 347) | typedef EigenBase2EigenBase Kind;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Block.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 117) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 127) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
type typename (line 158) | typedef typename XprType::StorageIndex StorageIndex;
function Impl (line 162) | inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
function EIGEN_DEVICE_FUNC (line 163) | EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index startRow, Index s...
function EIGEN_DEVICE_FUNC (line 164) | EIGEN_DEVICE_FUNC
function namespace (line 169) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/BooleanRedux.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/CommaInitializer.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 116) | EIGEN_DEVICE_FUNC
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/ConditionEstimator.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/CoreEvaluators.h
function namespace (line 16) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 241) | EIGEN_DEVICE_FUNC evaluator() {}
function EIGEN_DEVICE_FUNC (line 243) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
function EIGEN_DEVICE_FUNC (line 254) | EIGEN_DEVICE_FUNC evaluator() {}
function EIGEN_DEVICE_FUNC (line 256) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
function EIGEN_DEVICE_FUNC (line 275) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& t) : m_argImpl...
type typename (line 277) | typedef typename XprType::Scalar Scalar;
type typename (line 278) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 281) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 287) | CoeffReturnType coeff(Index index) const
function typename (line 299) | typename XprType::Scalar& coeffRef(Index index)
function PacketType (line 306) | PacketType packet(Index row, Index col) const
function PacketType (line 313) | PacketType packet(Index index) const
function writePacket (line 320) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 327) | void writePacket(Index index, const PacketType& x)
function EIGEN_STRONG_INLINE (line 349) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 351) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 352) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {...
function EIGEN_STRONG_INLINE (line 382) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 388) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 390) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {...
function EIGEN_STRONG_INLINE (line 430) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 438) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 445) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
type typename (line 459) | typedef typename internal::remove_all<PlainObjectType>::type PlainObject...
function EIGEN_DEVICE_FUNC (line 472) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
type typename (line 478) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function EIGEN_STRONG_INLINE (line 481) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 488) | EIGEN_STRONG_INLINE
function PacketType (line 496) | PacketType packet(IndexType row, IndexType col) const
function PacketType (line 503) | PacketType packet(IndexType index) const
function explicit (line 530) | explicit unary_evaluator(const XprType& op)
type typename (line 538) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 541) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 547) | CoeffReturnType coeff(Index index) const
function PacketType (line 554) | PacketType packet(Index row, Index col) const
function PacketType (line 561) | PacketType packet(Index index) const
type ternary_evaluator (line 579) | typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > ...
function EIGEN_DEVICE_FUNC (line 581) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
type typename (line 622) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 625) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 631) | CoeffReturnType coeff(Index index) const
function PacketType (line 638) | PacketType packet(Index row, Index col) const
function PacketType (line 647) | PacketType packet(Index index) const
type binary_evaluator (line 669) | typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
function EIGEN_DEVICE_FUNC (line 671) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
type typename (line 708) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 711) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 717) | CoeffReturnType coeff(Index index) const
function PacketType (line 724) | PacketType packet(Index row, Index col) const
function PacketType (line 732) | PacketType packet(Index index) const
function EIGEN_DEVICE_FUNC (line 760) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
type typename (line 768) | typedef typename XprType::Scalar Scalar;
type typename (line 769) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 772) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 778) | CoeffReturnType coeff(Index index) const
type Derived (line 810) | typedef Derived XprType;
type typename (line 811) | typedef typename XprType::PointerType PointerType;
type typename (line 812) | typedef typename XprType::Scalar Scalar;
type typename (line 813) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 832) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 838) | CoeffReturnType coeff(Index index) const
function PacketType (line 857) | PacketType packet(Index row, Index col) const
function PacketType (line 865) | PacketType packet(Index index) const
function writePacket (line 872) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 880) | void writePacket(Index index, const PacketType& x)
type typename (line 900) | typedef typename XprType::Scalar Scalar;
type typename (line 902) | typedef typename packet_traits<Scalar>::type PacketScalar;
function EIGEN_DEVICE_FUNC (line 923) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map)
function EIGEN_DEVICE_FUNC (line 941) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& ref)
type typename (line 956) | typedef typename XprType::Scalar Scalar;
type typename (line 958) | typedef typename packet_traits<Scalar>::type PacketScalar;
type block_evaluator (line 993) | typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block...
function EIGEN_DEVICE_FUNC (line 994) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& block) : block_evalu...
function EIGEN_DEVICE_FUNC (line 1007) | EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block)
type typename (line 1025) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1032) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1038) | CoeffReturnType coeff(Index index) const
function PacketType (line 1057) | PacketType packet(Index row, Index col) const
function PacketType (line 1064) | PacketType packet(Index index) const
function writePacket (line 1072) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1079) | void writePacket(Index index, const PacketType& x)
type typename (line 1101) | typedef typename XprType::Scalar Scalar;
type typename (line 1139) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1142) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1151) | CoeffReturnType coeff(Index index) const
type typename (line 1173) | typedef typename XprType::CoeffReturnType CoeffReturnType;
type typename (line 1177) | typedef typename internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
type typename (line 1178) | typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNested...
function CoeffReturnType (line 1210) | CoeffReturnType coeff(Index index) const
function PacketType (line 1222) | PacketType packet(Index row, Index col) const
function PacketType (line 1236) | PacketType packet(Index index) const
type typename (line 1260) | typedef typename internal::nested_eval<ArgType,1>::type ArgTypeNested;
type typename (line 1261) | typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNested...
type typename (line 1262) | typedef typename ArgType::Scalar InputScalar;
type typename (line 1263) | typedef typename XprType::Scalar Scalar;
type typename (line 1267) | typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)>...
function EIGEN_DEVICE_FUNC (line 1277) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr)
type typename (line 1284) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function Scalar (line 1287) | const Scalar coeff(Index i, Index j) const
function Scalar (line 1296) | const Scalar coeff(Index index) const
type typename (line 1319) | typedef typename remove_all<typename XprType::NestedExpressionType>::typ...
function EIGEN_DEVICE_FUNC (line 1326) | EIGEN_DEVICE_FUNC explicit evaluator_wrapper_base(const ArgType& arg) : ...
type typename (line 1328) | typedef typename ArgType::Scalar Scalar;
type typename (line 1329) | typedef typename ArgType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1332) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1338) | CoeffReturnType coeff(Index index) const
function PacketType (line 1357) | PacketType packet(Index row, Index col) const
function PacketType (line 1364) | PacketType packet(Index index) const
function writePacket (line 1371) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1378) | void writePacket(Index index, const PacketType& x)
function EIGEN_DEVICE_FUNC (line 1393) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
function EIGEN_DEVICE_FUNC (line 1404) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
type typename (line 1420) | typedef typename XprType::Scalar Scalar;
type typename (line 1421) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1460) | CoeffReturnType coeff(Index index) const
function PacketType (line 1480) | PacketType packet(Index row, Index col) const
function PacketType (line 1495) | PacketType packet(Index index) const
function writePacket (line 1503) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1520) | void writePacket(Index index, const PacketType& x)
function EIGEN_DEVICE_FUNC (line 1553) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& diagonal)
type typename (line 1558) | typedef typename XprType::Scalar Scalar;
type typename (line 1560) | typedef typename internal::conditional<!internal::is_same<typename
function CoeffReturnType (line 1564) | CoeffReturnType coeff(Index row, Index) const
function CoeffReturnType (line 1570) | CoeffReturnType coeff(Index index) const
function EvalToTemp (line 1619) | EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
type typename (line 1649) | typedef typename ArgType::PlainObject PlainObject;
type evaluator (line 1650) | typedef evaluator<PlainObject> Base;
function EIGEN_DEVICE_FUNC (line 1652) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
function EIGEN_DEVICE_FUNC (line 1659) | EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/CoreIterators.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/CwiseBinaryOp.h
function namespace (line 14) | namespace Eigen {
type typename (line 88) | typedef typename internal::remove_all<LhsType>::type Lhs;
type typename (line 89) | typedef typename internal::remove_all<RhsType>::type Rhs;
type typename (line 91) | typedef typename CwiseBinaryOpImpl<
type typename (line 99) | typedef typename internal::ref_selector<RhsType>::type RhsNested;
type typename (line 100) | typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
type typename (line 101) | typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/CwiseNullaryOp.h
function namespace (line 13) | namespace Eigen {
function if (line 137) | EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
function namespace (line 739) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/CwiseTernaryOp.h
function namespace (line 15) | namespace Eigen {
type typename (line 91) | typedef typename internal::remove_all<Arg2Type>::type Arg2;
type typename (line 92) | typedef typename internal::remove_all<Arg3Type>::type Arg3;
type typename (line 94) | typedef typename CwiseTernaryOpImpl<
type typename (line 100) | typedef typename internal::ref_selector<Arg2Type>::type Arg2Nested;
type typename (line 101) | typedef typename internal::ref_selector<Arg3Type>::type Arg3Nested;
type typename (line 102) | typedef typename internal::remove_reference<Arg1Nested>::type _Arg1Nested;
type typename (line 103) | typedef typename internal::remove_reference<Arg2Nested>::type _Arg2Nested;
type typename (line 104) | typedef typename internal::remove_reference<Arg3Nested>::type _Arg3Nested;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/CwiseUnaryOp.h
function namespace (line 14) | namespace Eigen {
type typename (line 62) | typedef typename internal::remove_all<XprType>::type NestedExpression;
function typename (line 84) | typename internal::remove_all<XprTypeNested>::type&
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/CwiseUnaryView.h
function namespace (line 13) | namespace Eigen {
type typename (line 65) | typedef typename internal::remove_all<MatrixType>::type NestedExpression;
function explicit (line 67) | explicit inline CwiseUnaryView(MatrixType& mat, const ViewOp& func = Vie...
function typename (line 83) | typename internal::remove_reference<MatrixTypeNested>::type&
type typename (line 107) | typedef typename internal::dense_xpr_base< CwiseUnaryView<ViewOp, Matrix...
function EIGEN_INHERIT_ASSIGNMENT_OPERATORS (line 109) | EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/DenseBase.h
function namespace (line 16) | namespace internal {
type typename (line 55) | typedef typename internal::traits<Derived>::StorageKind StorageKind;
type typename (line 63) | typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
type typename (line 66) | typedef typename internal::traits<Derived>::Scalar Scalar;
type Scalar (line 71) | typedef Scalar value_type;
type typename (line 73) | typedef typename NumTraits<Scalar>::Real RealScalar;
type DenseCoeffsBase (line 74) | typedef DenseCoeffsBase<Derived> Base;
type typename (line 96) | typedef typename Base::CoeffReturnType CoeffReturnType;
type typename (line 174) | typedef typename internal::find_best_packet<Scalar,SizeAtCompileTime>::t...
type Matrix (line 180) | typedef Matrix<typename
type Array (line 190) | typedef Array<typename
type typename (line 204) | typedef typename internal::conditional<internal::is_same<typename
function EIGEN_DEVICE_FUNC (line 240) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 251) | EIGEN_DEVICE_FUNC
type CwiseNullaryOp (line 262) | typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject>...
type CwiseNullaryOp (line 264) | typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,Plain...
type CwiseNullaryOp (line 266) | typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,Plain...
type Matrix (line 268) | typedef Matrix<typename
type Transpose (line 319) | typedef Transpose<Derived> TransposeReturnType;
type typename (line 322) | typedef typename internal::add_const<Transpose<const Derived> >::type Co...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/DenseCoeffsBase.h
function namespace (line 13) | namespace Eigen {
type typename (line 483) | typedef typename internal::traits<Derived>::Scalar Scalar;
type typename (line 484) | typedef typename NumTraits<Scalar>::Real RealScalar;
function Index (line 513) | inline Index stride() const
type typename (line 557) | typedef typename internal::traits<Derived>::Scalar Scalar;
type typename (line 558) | typedef typename NumTraits<Scalar>::Real RealScalar;
function Index (line 587) | inline Index stride() const
function EIGEN_DEVICE_FUNC (line 606) | EIGEN_DEVICE_FUNC
function Index (line 639) | inline Index first_aligned(const DenseBase<Derived>& m)
function Index (line 646) | inline Index first_default_aligned(const DenseBase<Derived>& m)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/DenseStorage.h
function namespace (line 21) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 125) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 132) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 162) | EIGEN_DEVICE_FUNC plain_array() {}
function EIGEN_DEVICE_FUNC (line 163) | EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert...
function EIGEN_DEVICE_FUNC (line 188) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 191) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 199) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
function EIGEN_DEVICE_FUNC (line 207) | EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
function EIGEN_DEVICE_FUNC (line 208) | EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
function EIGEN_DEVICE_FUNC (line 209) | EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 210) | EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 211) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 212) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 219) | EIGEN_DEVICE_FUNC DenseStorage() {}
function EIGEN_DEVICE_FUNC (line 220) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 221) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
function EIGEN_DEVICE_FUNC (line 223) | EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 264) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(r...
function EIGEN_DEVICE_FUNC (line 269) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols)...
function EIGEN_DEVICE_FUNC (line 270) | EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = ...
function EIGEN_DEVICE_FUNC (line 271) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 272) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 282) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 284) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other...
function EIGEN_DEVICE_FUNC (line 294) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
function EIGEN_DEVICE_FUNC (line 296) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 297) | EIGEN_DEVICE_FUNC Index cols(void) const {return _Cols;}
function EIGEN_DEVICE_FUNC (line 298) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_...
function EIGEN_DEVICE_FUNC (line 299) | EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; }
function EIGEN_DEVICE_FUNC (line 300) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 301) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 311) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 313) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other...
function EIGEN_DEVICE_FUNC (line 323) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
function EIGEN_DEVICE_FUNC (line 325) | EIGEN_DEVICE_FUNC Index rows(void) const {return _Rows;}
function EIGEN_DEVICE_FUNC (line 326) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function conservativeResize (line 327) | void conservativeResize(Index, Index, Index cols) { m_cols = cols; }
function resize (line 328) | void resize(Index, Index, Index cols) { m_cols = cols; }
function EIGEN_DEVICE_FUNC (line 329) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 330) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 349) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 386) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 389) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 390) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function conservativeResize (line 391) | void conservativeResize(Index size, Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 397) | EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
function explicit (line 422) | explicit DenseStorage(internal::constructor_without_unaligned_array_asse...
function EIGEN_DEVICE_FUNC (line 423) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_d...
function EIGEN_DEVICE_FUNC (line 429) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 445) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 462) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 464) | EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
function EIGEN_DEVICE_FUNC (line 465) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function EIGEN_DEVICE_FUNC (line 466) | EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
function resize (line 471) | void resize(Index size, Index, Index cols)
function explicit (line 495) | explicit DenseStorage(internal::constructor_without_unaligned_array_asse...
function EIGEN_DEVICE_FUNC (line 496) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_d...
function EIGEN_DEVICE_FUNC (line 502) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 518) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 535) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 537) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 538) | EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
function conservativeResize (line 539) | void conservativeResize(Index size, Index rows, Index)
function resize (line 544) | void resize(Index size, Index rows, Index)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Diagonal.h
function namespace (line 14) | namespace Eigen {
type typename (line 69) | typedef typename internal::dense_xpr_base<Diagonal>::type Base;
function explicit (line 73) | explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) ...
type typename (line 99) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 105) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 107) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 110) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 117) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 123) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 129) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 136) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 142) | EIGEN_DEVICE_FUNC
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/DiagonalMatrix.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 142) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 146) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 150) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 154) | EIGEN_DEVICE_FUNC
function m_diagonal (line 160) | inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diago...
function m_diagonal (line 164) | inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.di...
function explicit (line 170) | explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : ...
function EIGEN_DEVICE_FUNC (line 195) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 198) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 201) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 204) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 207) | EIGEN_DEVICE_FUNC
function namespace (line 225) | namespace internal {
type _DiagonalVectorType (line 250) | typedef _DiagonalVectorType DiagonalVectorType;
type DiagonalWrapper (line 251) | typedef DiagonalWrapper Nested;
function m_diagonal (line 256) | inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_di...
function namespace (line 309) | namespace internal {
function run (line 335) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/DiagonalProduct.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Dot.h
function namespace (line 13) | namespace Eigen {
type internal (line 74) | typedef internal::scalar_conj_product_op<Scalar,typename
type typename (line 122) | typedef typename internal::nested_eval<Derived,2>::type _Nested;
type typename (line 165) | typedef typename internal::nested_eval<Derived,3>::type _Nested;
function namespace (line 197) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/EigenBase.h
function namespace (line 14) | namespace Eigen {
function evalTo (line 70) | inline void evalTo(Dest& dst) const
function addTo (line 76) | inline void addTo(Dest& dst) const
function subTo (line 88) | inline void subTo(Dest& dst) const
function applyThisOnTheRight (line 99) | inline void applyThisOnTheRight(Dest& dst) const
function applyThisOnTheLeft (line 108) | inline void applyThisOnTheLeft(Dest& dst) const
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/ForceAlignedAccess.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Fuzzy.h
function namespace (line 14) | namespace Eigen {
function typename (line 65) | typename Derived::RealScalar& prec)
function EIGEN_DEVICE_FUNC (line 74) | EIGEN_DEVICE_FUNC
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/GeneralProduct.h
function namespace (line 14) | namespace Eigen {
type product_type_selector (line 88) | struct product_type_selector
type product_type_selector (line 89) | struct product_type_selector
type product_type_selector (line 90) | struct product_type_selector
type product_type_selector (line 91) | struct product_type_selector
type product_type_selector (line 92) | struct product_type_selector
type product_type_selector (line 93) | struct product_type_selector
type product_type_selector (line 94) | struct product_type_selector
type product_type_selector (line 95) | struct product_type_selector
type product_type_selector (line 96) | struct product_type_selector
type product_type_selector (line 97) | struct product_type_selector
type product_type_selector (line 98) | struct product_type_selector
type product_type_selector (line 99) | struct product_type_selector
type product_type_selector (line 100) | struct product_type_selector
type product_type_selector (line 101) | struct product_type_selector
type product_type_selector (line 102) | struct product_type_selector
type product_type_selector (line 103) | struct product_type_selector
type product_type_selector (line 104) | struct product_type_selector
type product_type_selector (line 105) | struct product_type_selector
type product_type_selector (line 106) | struct product_type_selector
type product_type_selector (line 107) | struct product_type_selector
function namespace (line 137) | namespace internal {
function namespace (line 144) | namespace internal {
function EIGEN_STRONG_INLINE (line 169) | EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
function EIGEN_STRONG_INLINE (line 174) | EIGEN_STRONG_INLINE Scalar* data() {
type gemv_dense_selector (line 196) | struct gemv_dense_selector
function run (line 199) | inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typena...
type gemv_dense_selector (line 275) | struct gemv_dense_selector
function run (line 278) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
type gemv_dense_selector (line 328) | struct gemv_dense_selector
function run (line 331) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
type gemv_dense_selector (line 342) | struct gemv_dense_selector
function run (line 345) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/GenericPacketMath.h
function namespace (line 14) | namespace Eigen {
function ptranspose (line 543) | inline void
function Packet (line 556) | inline Packet
function Packet (line 562) | inline Packet
function Packet (line 576) | inline Packet
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/GlobalFunctions.h
function namespace (line 54) | namespace Eigen
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/IO.h
function namespace (line 14) | namespace Eigen {
function namespace (line 126) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Inverse.h
function namespace (line 13) | namespace Eigen {
type typename (line 73) | typedef typename XprType::Scalar Scalar;
function namespace (line 80) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Map.h
function namespace (line 14) | namespace Eigen {
type PointerType (line 97) | typedef PointerType PointerArgType;
function EIGEN_DEVICE_FUNC (line 98) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 101) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 121) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 134) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 148) | EIGEN_DEVICE_FUNC
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/MapBase.h
function namespace (line 18) | namespace Eigen {
type typename (line 223) | typedef typename Base::Scalar Scalar;
type typename (line 224) | typedef typename Base::PacketScalar PacketScalar;
type typename (line 225) | typedef typename Base::StorageIndex StorageIndex;
type typename (line 226) | typedef typename Base::PointerType PointerType;
type typename (line 240) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 246) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 248) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 251) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 257) | EIGEN_DEVICE_FUNC
function Base (line 279) | Base(dataPtr) {}
function EIGEN_DEVICE_FUNC (line 280) | EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : B...
function EIGEN_DEVICE_FUNC (line 281) | EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index ...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/MathFunctions.h
function namespace (line 18) | namespace Eigen {
type Scalar (line 573) | typedef Scalar type;
function Scalar (line 586) | static inline Scalar run()
type typename (line 644) | typedef typename conditional<NumTraits<Scalar>::IsSigned,std::ptrdiff_t,...
function Scalar (line 662) | static inline Scalar run()
function Scalar (line 685) | static inline Scalar run()
function isinf_impl (line 745) | bool>::type
function isinf_msvc_helper (line 777) | bool isinf_msvc_helper(T x)
function EIGEN_DEVICE_FUNC (line 783) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return ...
function EIGEN_DEVICE_FUNC (line 784) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x) { return ...
function EIGEN_DEVICE_FUNC (line 785) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x) { return ...
function EIGEN_DEVICE_FUNC (line 787) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return ...
function EIGEN_DEVICE_FUNC (line 788) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x) { return ...
function EIGEN_DEVICE_FUNC (line 789) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x) { return ...
function isnan_impl (line 801) | bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
function isnan_impl (line 802) | bool isnan_impl(const double& x) { return __builtin_isnan(x); }
function isnan_impl (line 803) | bool isnan_impl(const float& x) { return __builtin_isnan(x); }
function isinf_impl (line 804) | bool isinf_impl(const double& x) { return __builtin_isinf(x); }
function isinf_impl (line 805) | bool isinf_impl(const float& x) { return __builtin_isinf(x); }
function isinf_impl (line 806) | bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
function namespace (line 827) | namespace numext {
function floor (line 993) | float floor(const float &x) { return ::floorf(x); }
function floor (line 996) | double floor(const double &x) { return ::floor(x); }
function ceil (line 1009) | float ceil(const float &x) { return ::ceilf(x); }
function ceil (line 1012) | double ceil(const double &x) { return ::ceil(x); }
function log2 (line 1018) | inline int log2(int x)
function log (line 1056) | float log(const float &x) { return ::logf(x); }
function log (line 1059) | double log(const double &x) { return ::log(x); }
function abs (line 1071) | float abs(const float &x) { return ::fabsf(x); }
function abs (line 1074) | double abs(const double &x) { return ::fabs(x); }
function exp (line 1096) | float exp(const float &x) { return ::expf(x); }
function exp (line 1099) | double exp(const double &x) { return ::exp(x); }
function cos (line 1111) | float cos(const float &x) { return ::cosf(x); }
function cos (line 1114) | double cos(const double &x) { return ::cos(x); }
function sin (line 1126) | float sin(const float &x) { return ::sinf(x); }
function sin (line 1129) | double sin(const double &x) { return ::sin(x); }
function tan (line 1141) | float tan(const float &x) { return ::tanf(x); }
function tan (line 1144) | double tan(const double &x) { return ::tan(x); }
function acos (line 1156) | float acos(const float &x) { return ::acosf(x); }
function acos (line 1159) | double acos(const double &x) { return ::acos(x); }
function asin (line 1171) | float asin(const float &x) { return ::asinf(x); }
function asin (line 1174) | double asin(const double &x) { return ::asin(x); }
function atan (line 1186) | float atan(const float &x) { return ::atanf(x); }
function atan (line 1189) | double atan(const double &x) { return ::atan(x); }
function cosh (line 1202) | float cosh(const float &x) { return ::coshf(x); }
function cosh (line 1205) | double cosh(const double &x) { return ::cosh(x); }
function sinh (line 1217) | float sinh(const float &x) { return ::sinhf(x); }
function sinh (line 1220) | double sinh(const double &x) { return ::sinh(x); }
function tanh (line 1232) | float tanh(float x) { return internal::generic_fast_tanh_float(x); }
function tanh (line 1237) | float tanh(const float &x) { return ::tanhf(x); }
function tanh (line 1240) | double tanh(const double &x) { return ::tanh(x); }
function fmod (line 1253) | float fmod(const float& a, const float& b) {
function fmod (line 1259) | double fmod(const double& a, const double& b) {
function namespace (line 1266) | namespace internal {
type typename (line 1319) | typedef typename NumTraits<Scalar>::Real RealScalar;
function isMuchSmallerThan (line 1321) | static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, con...
function EIGEN_DEVICE_FUNC (line 1325) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 1330) | EIGEN_DEVICE_FUNC
type typename (line 1340) | typedef typename NumTraits<Scalar>::Real RealScalar;
function isMuchSmallerThan (line 1342) | static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar&...
function EIGEN_DEVICE_FUNC (line 1346) | EIGEN_DEVICE_FUNC
function isMuchSmallerThan (line 1357) | bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
function isApprox (line 1364) | bool isApprox(const Scalar& x, const Scalar& y,
function isApproxOrLessThan (line 1371) | bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
function bool (line 1381) | struct random_impl<bool>
function bool (line 1389) | struct scalar_fuzzy_impl<bool>
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/MathFunctionsImpl.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Matrix.h
function namespace (line 14) | namespace Eigen {
type PlainObjectBase (line 186) | typedef PlainObjectBase<Matrix> Base;
function explicit (line 267) | explicit Matrix(internal::constructor_without_unaligned_array_assert)
function EIGEN_DEVICE_FUNC (line 272) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 293) | EIGEN_STRONG_INLINE explicit Matrix(const T& x)
function EIGEN_STRONG_INLINE (line 301) | EIGEN_STRONG_INLINE Matrix(const T0& x, const T1& y)
function Base (line 370) | Matrix(const Matrix& other) : Base(other)
function EIGEN_STRONG_INLINE (line 378) | EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
type internal (line 401) | struct internal
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/MatrixBase.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/NestByValue.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/NoAlias.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/NumTraits.h
function namespace (line 13) | namespace Eigen {
type T (line 100) | typedef T Real;
type typename (line 101) | typedef typename internal::conditional<
type T (line 106) | typedef T Nested;
type T (line 107) | typedef T Literal;
function EIGEN_DEVICE_FUNC (line 109) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 115) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 121) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 129) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 134) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 139) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
type NumTraits (line 153) | struct NumTraits
function EIGEN_DEVICE_FUNC (line 156) | EIGEN_DEVICE_FUNC
type NumTraits (line 160) | struct NumTraits
function EIGEN_DEVICE_FUNC (line 162) | EIGEN_DEVICE_FUNC
type NumTraits (line 166) | struct NumTraits
function dummy_precision (line 169) | static inline long double dummy_precision() { return 1e-15l; }
type _Real (line 175) | typedef _Real Real;
type typename (line 176) | typedef typename NumTraits<_Real>::Literal Literal;
function EIGEN_DEVICE_FUNC (line 185) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 187) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 189) | EIGEN_DEVICE_FUNC
type typename (line 197) | typedef typename NumTraits<Scalar>::Real RealScalar;
type Array (line 198) | typedef Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols> Real;
type typename (line 199) | typedef typename NumTraits<Scalar>::NonInteger NonIntegerScalar;
type Array (line 200) | typedef Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols> N...
type ArrayType (line 201) | typedef ArrayType & Nested;
type typename (line 202) | typedef typename NumTraits<Scalar>::Literal Literal;
function EIGEN_DEVICE_FUNC (line 214) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 216) | EIGEN_DEVICE_FUNC
function string (line 220) | struct NumTraits<std::string>
function void (line 242) | struct NumTraits<void> {}
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/PermutationMatrix.h
function namespace (line 14) | namespace Eigen {
function namespace (line 282) | namespace internal {
type internal (line 311) | typedef internal::traits<PermutationMatrix> Traits;
type typename (line 317) | typedef typename Traits::IndicesType IndicesType;
type typename (line 318) | typedef typename Traits::StorageIndex StorageIndex;
function explicit (line 326) | explicit inline PermutationMatrix(Index size) : m_indices(size)
function m_indices (line 339) | inline PermutationMatrix(const PermutationMatrix& other) : m_indices(oth...
function m_indices (line 350) | inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(i...
function namespace (line 419) | namespace internal {
type internal (line 436) | typedef internal::traits<Map> Traits;
type typename (line 440) | typedef typename Traits::IndicesType IndicesType;
type typename (line 441) | typedef typename IndicesType::Scalar StorageIndex;
function m_indices (line 444) | inline Map(const StorageIndex* indicesPtr)
function namespace (line 484) | namespace internal {
type internal (line 517) | typedef internal::traits<PermutationWrapper> Traits;
type typename (line 521) | typedef typename Traits::IndicesType IndicesType;
function m_indices (line 524) | inline PermutationWrapper(const IndicesType& indices)
type internal (line 568) | typedef internal::traits<PermutationType> PermTraits;
type typename (line 576) | typedef typename PermutationType::DenseMatrixType DenseMatrixType;
function namespace (line 625) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/PlainObjectBase.h
function namespace (line 25) | namespace Eigen {
function Scalar (line 154) | const Scalar& coeff(Index rowId, Index colId) const
function Scalar (line 167) | const Scalar& coeff(Index index) const
function Scalar (line 198) | const Scalar& coeffRef(Index rowId, Index colId) const
function Scalar (line 209) | const Scalar& coeffRef(Index index) const
function PacketScalar (line 216) | PacketScalar packet(Index rowId, Index colId) const
function PacketScalar (line 226) | PacketScalar packet(Index index) const
function writePacket (line 233) | void writePacket(Index rowId, Index colId, const PacketScalar& val)
function writePacket (line 243) | void writePacket(Index index, const PacketScalar& val)
function Scalar (line 249) | const Scalar *data() const
function Scalar (line 253) | Scalar *data()
function resize (line 273) | void resize(Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 302) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 327) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 341) | EIGEN_DEVICE_FUNC
function conservativeResize (line 384) | void conservativeResize(Index rows, Index cols)
function conservativeResize (line 397) | void conservativeResize(Index rows, NoChange_t)
function conservativeResize (line 411) | void conservativeResize(NoChange_t, Index cols)
function conservativeResize (line 426) | void conservativeResize(Index size)
function EIGEN_DEVICE_FUNC (line 487) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 496) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 515) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 526) | EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
function EIGEN_STRONG_INLINE (line 537) | EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
function EIGEN_STRONG_INLINE (line 547) | EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& o...
function ConstMapType (line 576) | static inline ConstMapType Map(const Scalar* data)
function MapType (line 578) | static inline MapType Map(Scalar* data)
function ConstMapType (line 580) | static inline ConstMapType Map(const Scalar* data, Index size)
function MapType (line 582) | static inline MapType Map(Scalar* data, Index size)
function ConstMapType (line 584) | static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
function MapType (line 586) | static inline MapType Map(Scalar* data, Index rows, Index cols)
function ConstAlignedMapType (line 589) | static inline ConstAlignedMapType MapAligned(const Scalar* data)
function AlignedMapType (line 591) | static inline AlignedMapType MapAligned(Scalar* data)
function ConstAlignedMapType (line 593) | static inline ConstAlignedMapType MapAligned(const Scalar* data, Index s...
function AlignedMapType (line 595) | static inline AlignedMapType MapAligned(Scalar* data, Index size)
function ConstAlignedMapType (line 597) | static inline ConstAlignedMapType MapAligned(const Scalar* data, Index r...
function AlignedMapType (line 599) | static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index ...
function _init2 (line 746) | void _init2(const Index& val0, const Index& val1,
function _init1 (line 784) | void _init1(const Index& val0,
function _init1 (line 797) | void _init1(const Scalar* data){
function EIGEN_STRONG_INLINE (line 825) | EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCo...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Product.h
function namespace (line 13) | namespace Eigen {
type _Rhs (line 79) | typedef _Rhs Rhs;
type typename (line 81) | typedef typename ProductImpl<
type typename (line 89) | typedef typename internal::ref_selector<Rhs>::type RhsNested;
type typename (line 90) | typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
type typename (line 91) | typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
function EIGEN_DEVICE_FUNC (line 93) | EIGEN_DEVICE_FUNC Product(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), ...
function namespace (line 112) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/ProductEvaluators.h
function namespace (line 16) | namespace Eigen {
type evaluator (line 56) | typedef evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1...
function EIGEN_DEVICE_FUNC (line 58) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
type evaluator (line 69) | typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagInd...
function EIGEN_DEVICE_FUNC (line 71) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
type typename (line 100) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 101) | typedef evaluator<PlainObject> Base;
function explicit (line 107) | explicit product_evaluator(const XprType& xpr)
type Product (line 157) | typedef Product<Lhs,Rhs,Options> SrcXprType;
type Product (line 175) | typedef Product<Lhs,Rhs,Options> SrcXprType;
type CwiseBinaryOp (line 196) | typedef CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>,
type typename (line 490) | typedef typename find_best_packet<Scalar,RowsAtCompileTime>::type LhsVec...
type typename (line 491) | typedef typename find_best_packet<Scalar,ColsAtCompileTime>::type RhsVec...
function CoeffReturnType (line 551) | const CoeffReturnType coeff(Index row, Index col) const
function EIGEN_DEVICE_FUNC (line 560) | EIGEN_DEVICE_FUNC const CoeffReturnType coeff(Index index) const
function PacketType (line 568) | PacketType packet(Index row, Index col) const
function PacketType (line 579) | PacketType packet(Index index) const
type Product (line 601) | typedef Product<Lhs, Rhs, DefaultProduct> XprType;
type Product (line 602) | typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
type product_evaluator (line 603) | typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape...
function EIGEN_DEVICE_FUNC (line 607) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function EIGEN_STRONG_INLINE (line 619) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 629) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 639) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 648) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 657) | static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const ...
function EIGEN_STRONG_INLINE (line 666) | static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const ...
function EIGEN_STRONG_INLINE (line 675) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 686) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
type typename (line 707) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 721) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 742) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 755) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 773) | typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename
type diagonal_product_evaluator_base (line 832) | typedef diagonal_product_evaluator_base<Rhs, typename
type typename (line 836) | typedef typename Base::Scalar Scalar;
type Product (line 838) | typedef Product<Lhs, Rhs, ProductKind> XprType;
type typename (line 839) | typedef typename XprType::PlainObject PlainObject;
function EIGEN_DEVICE_FUNC (line 845) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function Scalar (line 850) | const Scalar coeff(Index row, Index col) const
function PacketType (line 857) | PacketType packet(Index row, Index col) const
function PacketType (line 866) | PacketType packet(Index idx) const
type diagonal_product_evaluator_base (line 878) | typedef diagonal_product_evaluator_base<Lhs, typename
type typename (line 882) | typedef typename Base::Scalar Scalar;
type Product (line 884) | typedef Product<Lhs, Rhs, ProductKind> XprType;
type typename (line 885) | typedef typename XprType::PlainObject PlainObject;
function EIGEN_DEVICE_FUNC (line 889) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function Scalar (line 894) | const Scalar coeff(Index row, Index col) const
function PacketType (line 901) | PacketType packet(Index row, Index col) const
function PacketType (line 908) | PacketType packet(Index idx) const
type typename (line 930) | typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
type typename (line 931) | typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
function run (line 934) | inline void run(Dest& dst, const PermutationType& perm, const Expression...
type typename (line 1038) | typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
type typename (line 1039) | typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
function run (line 1042) | inline void run(Dest& dst, const TranspositionType& tr, const Expression...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Random.h
function namespace (line 15) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Redux.h
function namespace (line 14) | namespace Eigen {
type typename (line 145) | typedef typename Derived::Scalar Scalar;
type typename (line 146) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
type typename (line 166) | typedef typename Derived::Scalar Scalar;
type typename (line 167) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 190) | Scalar run(const Derived &mat, const Func& func)
type typename (line 213) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 215) | static Scalar run(const Derived &mat, const Func& func)
type typename (line 272) | typedef typename redux_traits<Func, Derived>::PacketType PacketType;
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC static Scalar run(const Derived &mat, const Func& func)
type typename (line 311) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 317) | Scalar run(const Derived &mat, const Func& func)
function EIGEN_DEVICE_FUNC (line 338) | EIGEN_DEVICE_FUNC explicit redux_evaluator(const XprType &xpr) : m_evalu...
type typename (line 340) | typedef typename XprType::Scalar Scalar;
type typename (line 341) | typedef typename XprType::CoeffReturnType CoeffReturnType;
type typename (line 342) | typedef typename XprType::PacketScalar PacketScalar;
type typename (line 343) | typedef typename XprType::PacketReturnType PacketReturnType;
function EIGEN_DEVICE_FUNC (line 363) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 367) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 379) | EIGEN_DEVICE_FUNC
type typename (line 415) | typedef typename internal::redux_evaluator<Derived> ThisEvaluator;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Ref.h
function namespace (line 13) | namespace Eigen {
type typename (line 61) | typedef typename internal::traits<Derived>::PlainObjectType PlainObjectT...
type typename (line 62) | typedef typename internal::traits<Derived>::StrideType StrideType;
function Index (line 69) | inline Index innerStride() const
function EIGEN_DEVICE_FUNC (line 251) | EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
function construct (line 263) | void construct(const Expression& expr,internal::true_type)
function construct (line 269) | void construct(const Expression& expr, internal::false_type)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Replicate.h
function namespace (line 13) | namespace Eigen {
type typename (line 64) | typedef typename internal::traits<Replicate>::MatrixTypeNested MatrixTyp...
type typename (line 65) | typedef typename internal::traits<Replicate>::_MatrixTypeNested _MatrixT...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/ReturnByValue.h
function namespace (line 14) | namespace Eigen {
type typename (line 56) | typedef typename internal::dense_xpr_base<ReturnByValue>::type Base;
function evalTo (line 61) | inline void evalTo(Dest& dst) const
function class (line 68) | class Unusable{
function namespace (line 88) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Reverse.h
function namespace (line 15) | namespace Eigen {
type internal (line 85) | typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> revers...
function m_matrix (line 88) | inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
function namespace (line 163) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Select.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 73) | inline EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 82) | inline EIGEN_DEVICE_FUNC
function typename (line 139) | typename ThenDerived::Scalar& elseScalar) const
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/SelfAdjointView.h
function namespace (line 13) | namespace Eigen {
type _MatrixType (line 54) | typedef _MatrixType MatrixType;
type TriangularBase (line 55) | typedef TriangularBase<SelfAdjointView> Base;
type typename (line 56) | typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested Mat...
type typename (line 57) | typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedClea...
type MatrixTypeNestedCleaned (line 58) | typedef MatrixTypeNestedCleaned NestedExpression;
type typename (line 61) | typedef typename internal::traits<SelfAdjointView>::Scalar Scalar;
type typename (line 62) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 68) | typedef typename MatrixType::PlainObject PlainObject;
function m_matrix (line 71) | inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
function EIGEN_DEVICE_FUNC (line 86) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 96) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 110) | EIGEN_DEVICE_FUNC
type typename (line 209) | typedef typename NumTraits<Scalar>::Real RealScalar;
type Matrix (line 211) | typedef Matrix<RealScalar, internal::traits<MatrixType>::ColsAtCompileTi...
function namespace (line 232) | namespace internal {
type typename (line 250) | typedef typename Base::DstXprType DstXprType;
type typename (line 251) | typedef typename Base::SrcXprType SrcXprType;
type typename (line 258) | typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
type typename (line 259) | typedef typename Base::Scalar Scalar;
type typename (line 260) | typedef typename Base::AssignmentTraits AssignmentTraits;
function EIGEN_DEVICE_FUNC (line 263) | EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &d...
function EIGEN_DEVICE_FUNC (line 267) | EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
function EIGEN_DEVICE_FUNC (line 275) | EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
function EIGEN_DEVICE_FUNC (line 280) | EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index, Index)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/SelfCwiseBinaryOp.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Solve.h
function namespace (line 13) | namespace Eigen {
type typename (line 66) | typedef typename internal::traits<Solve>::StorageIndex StorageIndex;
function namespace (line 110) | namespace internal {
type Solve (line 139) | typedef Solve<DecType,RhsType> SrcXprType;
function run (line 140) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
type Solve (line 155) | typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
function run (line 156) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 173) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/SolveTriangular.h
function namespace (line 13) | namespace Eigen {
function run (line 121) | static void run(const Lhs& lhs, Rhs& rhs)
function run (line 141) | static void run(const Lhs& lhs, Rhs& rhs)
type typename (line 173) | typedef typename internal::conditional<copy,
function namespace (line 192) | namespace internal {
type ReturnByValue (line 205) | typedef ReturnByValue<triangular_solve_retval> Base;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/SolverBase.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/StableNorm.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Stride.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Swap.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Transpose.h
function namespace (line 14) | namespace Eigen {
function namespace (line 90) | namespace internal {
type typename (line 128) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 134) | EIGEN_DEVICE_FUNC inline ScalarWithConstIfNotLvalue* data() { return der...
function EIGEN_DEVICE_FUNC (line 135) | EIGEN_DEVICE_FUNC inline const Scalar* data() const { return derived().n...
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
function namespace (line 219) | namespace internal {
type typename (line 239) | typedef typename MatrixType::Scalar Scalar;
type typename (line 240) | typedef typename internal::packet_traits<typename
function namespace (line 324) | namespace internal {
function run (line 343) | static bool run(const Scalar* dest, const OtherDerived& src)
function run (line 372) | static void run(const Derived& dst, const OtherDerived& other)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Transpositions.h
function namespace (line 13) | namespace Eigen {
type typename (line 164) | typedef typename Traits::IndicesType IndicesType;
type typename (line 165) | typedef typename IndicesType::Scalar StorageIndex;
function m_indices (line 177) | inline Transpositions(const Transpositions& other) : m_indices(other.ind...
function m_indices (line 182) | inline Transpositions(const MatrixBase<Other>& indices) : m_indices(indi...
function m_indices (line 205) | inline Transpositions(Index size) : m_indices(size)
function namespace (line 219) | namespace internal {
type typename (line 238) | typedef typename Traits::IndicesType IndicesType;
type typename (line 239) | typedef typename IndicesType::Scalar StorageIndex;
function explicit (line 241) | explicit inline Map(const StorageIndex* indicesPtr)
function namespace (line 278) | namespace internal {
type typename (line 295) | typedef typename Traits::IndicesType IndicesType;
type typename (line 296) | typedef typename IndicesType::Scalar StorageIndex;
function explicit (line 298) | explicit inline TranspositionsWrapper(IndicesType& indices)
function namespace (line 359) | namespace internal {
type TranspositionsDerived (line 371) | typedef TranspositionsDerived TranspositionType;
type typename (line 372) | typedef typename TranspositionType::IndicesType IndicesType;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/TriangularMatrix.h
function namespace (line 14) | namespace Eigen {
type typename (line 192) | typedef typename internal::traits<TriangularView>::Scalar Scalar;
type _MatrixType (line 193) | typedef _MatrixType MatrixType;
type typename (line 197) | typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRe...
type typename (line 199) | typedef typename internal::remove_all<typename
type typename (line 204) | typedef typename internal::traits<TriangularView>::MatrixTypeNestedClean...
function m_matrix (line 217) | inline TriangularView(MatrixType& matrix) : m_matrix(matrix)
function EIGEN_DEVICE_FUNC (line 236) | EIGEN_DEVICE_FUNC
type TriangularView (line 239) | typedef TriangularView<const MatrixConjugateReturnType,Mode> ConjugateRe...
function EIGEN_DEVICE_FUNC (line 241) | EIGEN_DEVICE_FUNC
type TriangularBase (line 339) | typedef TriangularBase<TriangularViewType> Base;
type typename (line 340) | typedef typename internal::traits<TriangularViewType>::Scalar Scalar;
type _MatrixType (line 342) | typedef _MatrixType MatrixType;
type typename (line 343) | typedef typename MatrixType::PlainObject DenseMatrixType;
type DenseMatrixType (line 344) | typedef DenseMatrixType PlainObject;
type typename (line 350) | typedef typename internal::traits<TriangularViewType>::StorageKind Stora...
function EIGEN_DEVICE_FUNC (line 389) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 392) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 396) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 399) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 405) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 415) | EIGEN_DEVICE_FUNC
function solveInPlace (line 506) | void solveInPlace(const MatrixBase<OtherDerived>& other) const
function swap (line 515) | void swap(TriangularBase<OtherDerived> const & other)
function namespace (line 693) | namespace internal {
type evaluator (line 711) | typedef evaluator<typename
function Base (line 712) | unary_evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
type Triangular2Triangular (line 716) | struct Triangular2Triangular {}
type Triangular2Dense (line 717) | struct Triangular2Dense {}
type Dense2Triangular (line 718) | struct Dense2Triangular {}
type typename (line 734) | typedef typename Base::DstXprType DstXprType;
type typename (line 735) | typedef typename Base::SrcXprType SrcXprType;
type typename (line 742) | typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
type typename (line 743) | typedef typename Base::Scalar Scalar;
type typename (line 744) | typedef typename Base::AssignmentTraits AssignmentTraits;
function EIGEN_DEVICE_FUNC (line 747) | EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &d...
function EIGEN_DEVICE_FUNC (line 752) | EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
function EIGEN_DEVICE_FUNC (line 761) | EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
function EIGEN_DEVICE_FUNC (line 768) | EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index row, Index col)
type evaluator (line 780) | typedef evaluator<DstXprType> DstEvaluatorType;
type evaluator (line 781) | typedef evaluator<SrcXprType> SrcEvaluatorType;
type triangular_dense_assignment_kernel (line 791) | typedef triangular_dense_assignment_kernel< Mode
function Kernel (line 793) | Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
type AssignmentKind (line 812) | struct AssignmentKind
type Triangular2Dense (line 812) | typedef Triangular2Dense Kind;
type AssignmentKind (line 813) | struct AssignmentKind
type Dense2Triangular (line 813) | typedef Dense2Triangular Kind;
type typename (line 851) | typedef typename DstEvaluatorType::XprType DstXprType;
type typename (line 858) | typedef typename Kernel::Scalar Scalar;
function namespace (line 933) | namespace internal {
function run (line 957) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 968) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/VectorBlock.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/VectorwiseOp.h
function namespace (line 14) | namespace Eigen {
function namespace (line 97) | namespace internal {
type typename (line 161) | typedef typename ExpressionType::RealScalar RealScalar;
type Eigen (line 162) | typedef Eigen::Index Index;
type typename (line 163) | typedef typename internal::ref_selector<ExpressionType>::non_const_type ...
type typename (line 164) | typedef typename internal::remove_all<ExpressionTypeNested>::type Expres...
type PartialReduxExpr (line 169) | typedef PartialReduxExpr<ExpressionType,
type PartialReduxExpr (line 177) | typedef PartialReduxExpr<ExpressionType,
function EIGEN_DEVICE_FUNC (line 195) | EIGEN_DEVICE_FUNC
type Replicate (line 208) | typedef Replicate<OtherDerived,
type Replicate (line 231) | typedef Replicate<OtherDerived,
function m_matrix (line 255) | inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {}
function EIGEN_DEVICE_FUNC (line 258) | EIGEN_DEVICE_FUNC
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/Visitor.h
function namespace (line 13) | namespace Eigen {
type typename (line 66) | typedef typename XprType::Scalar Scalar;
type typename (line 67) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function EIGEN_DEVICE_FUNC (line 78) | EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index row, Index col) const
type typename (line 109) | typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
function namespace (line 119) | namespace internal {
function typename (line 205) | typename internal::traits<Derived>::Scalar
function typename (line 223) | typename internal::traits<Derived>::Scalar
function typename (line 241) | typename internal::traits<Derived>::Scalar
function typename (line 259) | typename internal::traits<Derived>::Scalar
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AVX/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet4cf (line 124) | Packet4cf preverse(const Packet4cf& a) {
type conj_helper (line 174) | struct conj_helper
function EIGEN_STRONG_INLINE (line 176) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 179) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type conj_helper (line 185) | struct conj_helper
function EIGEN_STRONG_INLINE (line 187) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 190) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type conj_helper (line 196) | struct conj_helper
function EIGEN_STRONG_INLINE (line 198) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 201) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type conj_helper (line 207) | struct conj_helper
function EIGEN_STRONG_INLINE (line 209) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet8f& x, const Packet4cf& ...
function EIGEN_STRONG_INLINE (line 212) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet8f& x, const Packet4cf& y...
type conj_helper (line 216) | struct conj_helper
function EIGEN_STRONG_INLINE (line 218) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet8f& ...
function EIGEN_STRONG_INLINE (line 221) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& x, const Packet8f& y...
type Packet2cd (line 240) | struct Packet2cd
type packet_traits (line 247) | struct packet_traits
function default_packet_traits (line 247) | double> > : default_packet_traits
function Packet2cd (line 270) | struct unpacket_traits<Packet2cd> { typedef std::complex<double> type; e...
function Packet2cd (line 274) | Packet2cd pnegate(const Packet2cd& a) { return Packet2cd(pnegate(a.v)); }
function Packet2cd (line 275) | Packet2cd pconj(const Packet2cd& a)
function Packet2cd (line 335) | Packet2cd preverse(const Packet2cd& a) {
type conj_helper (line 370) | struct conj_helper
function EIGEN_STRONG_INLINE (line 372) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 375) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
type conj_helper (line 381) | struct conj_helper
function EIGEN_STRONG_INLINE (line 383) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 386) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
type conj_helper (line 392) | struct conj_helper
function EIGEN_STRONG_INLINE (line 394) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 397) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
type conj_helper (line 403) | struct conj_helper
function EIGEN_STRONG_INLINE (line 405) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet4d& x, const Packet2cd& ...
function EIGEN_STRONG_INLINE (line 408) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet4d& x, const Packet2cd& y...
type conj_helper (line 412) | struct conj_helper
function EIGEN_STRONG_INLINE (line 414) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet4d& ...
function EIGEN_STRONG_INLINE (line 417) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& x, const Packet4d& y...
function Packet4cf (line 459) | Packet4cf pinsertfirst(const Packet4cf& a, std::complex<float> b)
function Packet2cd (line 464) | Packet2cd pinsertfirst(const Packet2cd& a, std::complex<double> b)
function Packet4cf (line 469) | Packet4cf pinsertlast(const Packet4cf& a, std::complex<float> b)
function Packet2cd (line 474) | Packet2cd pinsertlast(const Packet2cd& a, std::complex<double> b)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AVX/MathFunctions.h
function namespace (line 17) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AVX/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet8f (line 136) | Packet8f pnegate(const Packet8f& a)
function Packet4d (line 140) | Packet4d pnegate(const Packet4d& a)
function Packet8f (line 145) | Packet8f pconj(const Packet8f& a) { return a; }
function Packet4d (line 146) | Packet4d pconj(const Packet4d& a) { return a; }
function Packet8i (line 147) | Packet8i pconj(const Packet8i& a) { return a; }
function Index (line 284) | Index stride)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AVX/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AVX512/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AVX512/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet16f (line 174) | Packet16f pnegate(const Packet16f& a) {
function Packet8d (line 178) | Packet8d pnegate(const Packet8d& a) {
function Packet16f (line 183) | Packet16f pconj(const Packet16f& a) {
function Packet8d (line 187) | Packet8d pconj(const Packet8d& a) {
function Packet16i (line 191) | Packet16i pconj(const Packet16i& a) {
function Packet16f (line 219) | Packet16f pmadd(const Packet16f& a, const Packet16f& b,
function Packet8d (line 224) | Packet8d pmadd(const Packet8d& a, const Packet8d& b,
function Packet16f (line 638) | Packet16f preverse(const Packet16f& a)
function Packet8d (line 643) | Packet8d preverse(const Packet8d& a)
function Packet16f (line 648) | Packet16f pabs(const Packet16f& a)
function Packet8d (line 654) | Packet8d pabs(const Packet8d& a) {
function Packet16f (line 1298) | Packet16f pblend(const Selector<16>& /*ifPacket*/,
function Packet8d (line 1305) | Packet8d pblend(const Selector<8>& /*ifPacket*/,
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AltiVec/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet2cf (line 100) | Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); }
function Packet2cf (line 101) | Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a....
function Packet2cf (line 137) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 194) | struct conj_helper
function EIGEN_STRONG_INLINE (line 196) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 199) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 205) | struct conj_helper
function EIGEN_STRONG_INLINE (line 207) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 210) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 216) | struct conj_helper
function EIGEN_STRONG_INLINE (line 218) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 221) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 227) | struct conj_helper
function EIGEN_STRONG_INLINE (line 229) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet4f& x, const Packet2cf& ...
function EIGEN_STRONG_INLINE (line 232) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet4f& x, const Packet2cf& y...
type conj_helper (line 236) | struct conj_helper
function EIGEN_STRONG_INLINE (line 238) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet4f& ...
function EIGEN_STRONG_INLINE (line 241) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& x, const Packet4f& y...
function Packet2cf (line 266) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
type Packet1cd (line 275) | struct Packet1cd
type packet_traits (line 282) | struct packet_traits
function default_packet_traits (line 282) | double> > : default_packet_traits
function Packet1cd (line 305) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 332) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 333) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd(pxor(a.v, reinter...
function Packet1cd (line 370) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 389) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 392) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 398) | struct conj_helper
function EIGEN_STRONG_INLINE (line 400) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 403) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 409) | struct conj_helper
function EIGEN_STRONG_INLINE (line 411) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 414) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 419) | struct conj_helper
function EIGEN_STRONG_INLINE (line 421) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet2d& x, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 424) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet2d& x, const Packet1cd& y...
type conj_helper (line 428) | struct conj_helper
function EIGEN_STRONG_INLINE (line 430) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet2d& ...
function EIGEN_STRONG_INLINE (line 433) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& x, const Packet2d& y...
function EIGEN_STRONG_INLINE (line 445) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AltiVec/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/AltiVec/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet4f (line 355) | Packet4f pnegate(const Packet4f& a) { return p4f_ZERO - a; }
function Packet4i (line 356) | Packet4i pnegate(const Packet4i& a) { return p4i_ZERO - a; }
function Packet4f (line 358) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet4i (line 359) | Packet4i pconj(const Packet4i& a) { return a; }
type __vector (line 756) | typedef __vector double Packet2d;
type Packet2ul (line 757) | typedef __vector unsigned long long Packet2ul;
type Packet2l (line 758) | typedef __vector long long Packet2l;
type Packet2ul (line 760) | typedef Packet2ul Packet2bl;
type __vector (line 762) | typedef __vector __bool
function default_packet_traits (line 789) | struct packet_traits<double> : default_packet_traits
function Packet2d (line 820) | struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, al...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/CUDA/Complex.h
function namespace (line 15) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/CUDA/Half.h
function namespace (line 46) | namespace Eigen {
function namespace (line 560) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/CUDA/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/CUDA/PacketMath.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/CUDA/PacketMathHalf.h
function namespace (line 14) | namespace Eigen {
function ptranspose (line 107) | void
type Packet16h (line 338) | typedef struct {
function Packet16h (line 343) | struct is_arithmetic<Packet16h> { enum { value = true }; }
function default_packet_traits (line 346) | struct packet_traits<half> : default_packet_traits {
function Packet16h (line 375) | struct unpacket_traits<Packet16h> { typedef Eigen::half type; enum {size...
function Packet16h (line 407) | Packet16h
function EIGEN_STRONG_INLINE (line 418) | EIGEN_STRONG_INLINE Packet16f half2float(const Packet16h& a) {
function EIGEN_STRONG_INLINE (line 446) | EIGEN_STRONG_INLINE Packet16h float2half(const Packet16f& a) {
type Packet8h (line 706) | typedef struct {
function Packet8h (line 711) | struct is_arithmetic<Packet8h> { enum { value = true }; }
function default_packet_traits (line 714) | struct packet_traits<Eigen::half> : default_packet_traits {
function Packet8h (line 743) | struct unpacket_traits<Packet8h> { typedef Eigen::half type; enum {size=...
function EIGEN_STRONG_INLINE (line 784) | EIGEN_STRONG_INLINE Packet8f half2float(const Packet8h& a) {
function EIGEN_STRONG_INLINE (line 803) | EIGEN_STRONG_INLINE Packet8h float2half(const Packet8f& a) {
function Packet8h (line 826) | Packet8h pconj(const Packet8h& a) { return a; }
type Packet4h (line 965) | typedef struct {
function Packet4h (line 970) | struct is_arithmetic<Packet4h> { enum { value = true }; }
function default_packet_traits (line 973) | struct packet_traits<Eigen::half> : default_packet_traits {
function Packet4h (line 1002) | struct unpacket_traits<Packet4h> { typedef Eigen::half type; enum {size=...
function Packet4h (line 1014) | Packet4h pconj(const Packet4h& a) { return a; }
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/CUDA/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/NEON/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet2cf (line 154) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 235) | struct conj_helper
function EIGEN_STRONG_INLINE (line 237) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 240) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 246) | struct conj_helper
function EIGEN_STRONG_INLINE (line 248) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 251) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 257) | struct conj_helper
function EIGEN_STRONG_INLINE (line 259) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 262) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type Packet1cd (line 299) | struct Packet1cd
type packet_traits (line 306) | struct packet_traits
function default_packet_traits (line 306) | double> > : default_packet_traits
function Packet1cd (line 329) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 339) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate<Packet2...
function Packet1cd (line 340) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd(vreinterpretq_f64...
function Packet1cd (line 408) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 428) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 431) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 437) | struct conj_helper
function EIGEN_STRONG_INLINE (line 439) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 442) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 448) | struct conj_helper
function EIGEN_STRONG_INLINE (line 450) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 453) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 469) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/NEON/MathFunctions.h
function namespace (line 15) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/NEON/PacketMath.h
function namespace (line 15) | namespace Eigen {
function Packet4f (line 309) | Packet4f preverse(const Packet4f& a) {
function Packet4i (line 318) | Packet4i preverse(const Packet4i& a) {
function Packet4f (line 328) | Packet4f pabs(const Packet4f& a) { return vabsq_f32(a); }
function Packet4i (line 329) | Packet4i pabs(const Packet4i& a) { return vabsq_s32(a); }
type float64x2_t (line 550) | typedef float64x2_t Packet2d;
type float64x1_t (line 551) | typedef float64x1_t Packet1d;
function default_packet_traits (line 553) | struct packet_traits<double> : default_packet_traits
function Packet2d (line 573) | struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, a...
function Packet2d (line 587) | Packet2d pnegate(const Packet2d& a) { return vnegq_f64(a); }
function Packet2d (line 589) | Packet2d pconj(const Packet2d& a) { return a; }
function Packet2d (line 597) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) ...
function Packet2d (line 599) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) ...
function Packet2d (line 656) | Packet2d preverse(const Packet2d& a) { return vcombine_f64(vget_high_f64...
function Packet2d (line 658) | Packet2d pabs(const Packet2d& a) { return vabsq_f64(a); }
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/SSE/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet2cf (line 148) | Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(...
type conj_helper (line 178) | struct conj_helper
function EIGEN_STRONG_INLINE (line 180) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 183) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 196) | struct conj_helper
function EIGEN_STRONG_INLINE (line 198) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 201) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 214) | struct conj_helper
function EIGEN_STRONG_INLINE (line 216) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 219) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 232) | struct conj_helper
function EIGEN_STRONG_INLINE (line 234) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet4f& x, const Packet2cf& ...
function EIGEN_STRONG_INLINE (line 237) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet4f& x, const Packet2cf& y...
type conj_helper (line 241) | struct conj_helper
function EIGEN_STRONG_INLINE (line 243) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet4f& ...
function EIGEN_STRONG_INLINE (line 246) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& x, const Packet4f& y...
function EIGEN_STRONG_INLINE (line 258) | EIGEN_STRONG_INLINE Packet2cf pcplxflip/* <Packet2cf> */(const Packet2cf...
type Packet1cd (line 265) | struct Packet1cd
type packet_traits (line 275) | struct packet_traits
function default_packet_traits (line 275) | double> > : default_packet_traits
function Packet1cd (line 299) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 303) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 304) | Packet1cd pconj(const Packet1cd& a)
function Packet1cd (line 352) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 381) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 384) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 397) | struct conj_helper
function EIGEN_STRONG_INLINE (line 399) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 402) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 415) | struct conj_helper
function EIGEN_STRONG_INLINE (line 417) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 420) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 433) | struct conj_helper
function EIGEN_STRONG_INLINE (line 435) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet2d& x, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 438) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet2d& x, const Packet1cd& y...
type conj_helper (line 442) | struct conj_helper
function EIGEN_STRONG_INLINE (line 444) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet2d& ...
function EIGEN_STRONG_INLINE (line 447) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& x, const Packet2d& y...
function EIGEN_STRONG_INLINE (line 459) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/* <Packet1cd> */(const Packet1cd...
function Packet2cf (line 474) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
function Packet2cf (line 479) | Packet2cf pinsertfirst(const Packet2cf& a, std::complex<float> b)
function Packet1cd (line 484) | Packet1cd pinsertfirst(const Packet1cd&, std::complex<double> b)
function Packet2cf (line 489) | Packet2cf pinsertlast(const Packet2cf& a, std::complex<float> b)
function Packet1cd (line 494) | Packet1cd pinsertlast(const Packet1cd&, std::complex<double> b)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/SSE/MathFunctions.h
function namespace (line 18) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/SSE/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet4f (line 435) | Packet4f preverse(const Packet4f& a)
function Packet2d (line 437) | Packet2d preverse(const Packet2d& a)
function Packet4i (line 439) | Packet4i preverse(const Packet4i& a)
function Packet4f (line 442) | Packet4f pabs(const Packet4f& a)
function Packet2d (line 447) | Packet2d pabs(const Packet2d& a)
function Packet4i (line 452) | Packet4i pabs(const Packet4i& a)
function EIGEN_STRONG_INLINE (line 494) | EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs)
function Packet4i (line 790) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,...
function Packet4f (line 800) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
function Packet2d (line 810) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,...
function Packet4f (line 821) | Packet4f pinsertfirst(const Packet4f& a, float b)
function Packet2d (line 830) | Packet2d pinsertfirst(const Packet2d& a, double b)
function Packet4f (line 839) | Packet4f pinsertlast(const Packet4f& a, float b)
function Packet2d (line 849) | Packet2d pinsertlast(const Packet2d& a, double b)
function pmadd (line 861) | float pmadd(const float& a, const float& b, const float& c) {
function pmadd (line 864) | double pmadd(const double& a, const double& b, const double& c) {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/SSE/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/ZVector/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet1cd (line 138) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet2cf (line 139) | Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(Packet4...
function Packet1cd (line 140) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd((Packet2d)vec_xor...
function Packet2cf (line 141) | Packet2cf pconj(const Packet2cf& a)
function Packet1cd (line 204) | Packet1cd preverse(const Packet1cd& a) { return a; }
function Packet2cf (line 205) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 273) | struct conj_helper
function EIGEN_STRONG_INLINE (line 275) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 278) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 284) | struct conj_helper
function EIGEN_STRONG_INLINE (line 286) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 289) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 295) | struct conj_helper
function EIGEN_STRONG_INLINE (line 297) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 300) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 306) | struct conj_helper
function EIGEN_STRONG_INLINE (line 308) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 311) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 317) | struct conj_helper
function EIGEN_STRONG_INLINE (line 319) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 322) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 328) | struct conj_helper
function EIGEN_STRONG_INLINE (line 330) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 333) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
function EIGEN_STRONG_INLINE (line 356) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
function EIGEN_STRONG_INLINE (line 361) | EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x)
function Packet2cf (line 383) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/ZVector/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/arch/ZVector/PacketMath.h
function namespace (line 15) | namespace Eigen {
function Packet4i (line 538) | Packet4i pnegate(const Packet4i& a) { return (-a); }
function Packet4f (line 539) | Packet4f pnegate(const Packet4f& a)
function Packet2d (line 546) | Packet2d pnegate(const Packet2d& a) { return (-a); }
function Packet4i (line 548) | Packet4i pconj(const Packet4i& a) { return a; }
function Packet4f (line 549) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet2d (line 550) | Packet2d pconj(const Packet2d& a) { return a; }
function Packet4i (line 552) | Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) ...
function Packet4f (line 553) | Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
function Packet2d (line 560) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) ...
function Packet4i (line 688) | Packet4i preverse(const Packet4i& a)
function Packet2d (line 693) | Packet2d preverse(const Packet2d& a)
function Packet4f (line 698) | Packet4f preverse(const Packet4f& a)
function Packet4i (line 918) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,...
function Packet4f (line 924) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
function Packet2d (line 935) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/functors/AssignmentFunctors.h
function namespace (line 13) | namespace Eigen {
function assignCoeff (line 70) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
function assignPacket (line 73) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 92) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a *= b; }
function assignPacket (line 95) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 113) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a /= b; }
function assignPacket (line 116) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 145) | void assignCoeff(Scalar& a, const Scalar& b) const
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/functors/BinaryFunctors.h
function namespace (line 13) | namespace Eigen {
type typename (line 116) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_pr...
function EIGEN_STRONG_INLINE (line 119) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 123) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 142) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_min_op>...
function EIGEN_STRONG_INLINE (line 144) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 146) | const Packet packetOp(const Packet& a, const Packet& b) const
function result_type (line 149) | const result_type predux(const Packet& a) const
type typename (line 168) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_max_op>...
function EIGEN_STRONG_INLINE (line 170) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 172) | const Packet packetOp(const Packet& a, const Packet& b) const
function result_type (line 175) | const result_type predux(const Packet& a) const
function const (line 211) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a=...
function const (line 218) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<b;}
function const (line 225) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<...
function const (line 232) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>b;}
function const (line 239) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>...
function const (line 246) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return !(...
function const (line 253) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a!...
function Scalar (line 267) | const Scalar operator() (const Scalar& _x, const Scalar& _y) const
type typename (line 301) | typedef typename ScalarBinaryOpTraits<Scalar,Exponent,scalar_pow_op>::Re...
type Scalar (line 306) | typedef Scalar LhsScalar;
type Exponent (line 307) | typedef Exponent RhsScalar;
function EIGEN_DEVICE_FUNC (line 311) | EIGEN_DEVICE_FUNC
type typename (line 331) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_differe...
function result_type (line 339) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) co...
function Packet (line 341) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 360) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotien...
function result_type (line 368) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) co...
function Packet (line 370) | const Packet packetOp(const Packet& a, const Packet& b) const
type scalar_boolean_and_op (line 389) | struct scalar_boolean_and_op {
function scalar_boolean_and_op (line 393) | struct functor_traits<scalar_boolean_and_op> {
type scalar_boolean_or_op (line 405) | struct scalar_boolean_or_op {
function scalar_boolean_or_op (line 409) | struct functor_traits<scalar_boolean_or_op> {
type scalar_boolean_xor_op (line 421) | struct scalar_boolean_xor_op {
function scalar_boolean_xor_op (line 425) | struct functor_traits<scalar_boolean_xor_op> {
type typename (line 442) | typedef typename BinaryOp::first_argument_type first_argument_type;
type typename (line 443) | typedef typename BinaryOp::second_argument_type second_argument_type;
type typename (line 444) | typedef typename BinaryOp::result_type result_type;
function m_value (line 446) | bind1st_op(const first_argument_type &val) : m_value(val) {}
function result_type (line 448) | const result_type operator() (const second_argument_type& b) const { ret...
function Packet (line 451) | const Packet packetOp(const Packet& b) const
type typename (line 461) | typedef typename BinaryOp::first_argument_type first_argument_type;
type typename (line 462) | typedef typename BinaryOp::second_argument_type second_argument_type;
type typename (line 463) | typedef typename BinaryOp::result_type result_type;
function m_value (line 465) | bind2nd_op(const second_argument_type &val) : m_value(val) {}
function result_type (line 467) | const result_type operator() (const first_argument_type& a) const { retu...
function Packet (line 470) | const Packet packetOp(const Packet& a) const
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/functors/NullaryFunctors.h
function namespace (line 13) | namespace Eigen {
function Scalar (line 137) | const Scalar operator() (IndexType i) const { return impl(i); }
function EIGEN_STRONG_INLINE (line 140) | EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const { return im...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/functors/StlFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/functors/TernaryFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/functors/UnaryFunctors.h
function namespace (line 13) | namespace Eigen {
function result_type (line 171) | result_type operator() (const Scalar& a) const { return numext::real(a); }
function result_type (line 187) | result_type operator() (const Scalar& a) const { return numext::imag(a); }
function Scalar (line 233) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 235) | inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
function Scalar (line 273) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 275) | inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
function Scalar (line 304) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 306) | inline Packet packetOp(const Packet& a) const { return internal::plog1p(...
function Scalar (line 324) | inline const Scalar operator() (const Scalar& a) const { EIGEN_USING_STD...
function Packet (line 326) | inline Packet packetOp(const Packet& a) const { return internal::plog10(...
function Scalar (line 338) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 340) | inline Packet packetOp(const Packet& a) const { return internal::psqrt(a...
function Scalar (line 365) | inline const Scalar operator() (const Scalar& a) const { return Scalar(1...
function Packet (line 367) | inline Packet packetOp(const Packet& a) const { return internal::prsqrt(...
function Scalar (line 384) | inline Scalar operator() (const Scalar& a) const { return numext::cos(a); }
function Packet (line 386) | inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
function Scalar (line 403) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 405) | inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
function Scalar (line 423) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 425) | inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
function Scalar (line 442) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 444) | inline Packet packetOp(const Packet& a) const { return internal::pacos(a...
function Scalar (line 461) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 463) | inline Packet packetOp(const Packet& a) const { return internal::pasin(a...
function Scalar (line 481) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 483) | inline Packet packetOp(const Packet& a) const { return internal::patan(a...
function Scalar (line 501) | inline const Scalar operator()(const Scalar& a) const { return numext::t...
function Packet (line 503) | inline Packet packetOp(const Packet& x) const { return ptanh(x); }
function Scalar (line 537) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 539) | inline Packet packetOp(const Packet& a) const { return internal::psinh(a...
function Scalar (line 556) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 558) | inline Packet packetOp(const Packet& a) const { return internal::pcosh(a...
function Scalar (line 576) | inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
function Packet (line 578) | inline const Packet packetOp(const Packet& a) const
function Scalar (line 592) | inline Scalar operator() (const Scalar& a) const { return a*a; }
function Packet (line 594) | inline const Packet packetOp(const Packet& a) const
function Scalar (line 608) | inline Scalar operator() (const Scalar& a) const { return a*a*a; }
function Packet (line 610) | inline const Packet packetOp(const Packet& a) const
function EIGEN_STRONG_INLINE (line 623) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 625) | inline Packet packetOp(const Packet& a) const { return internal::pround(...
function EIGEN_STRONG_INLINE (line 642) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 644) | inline Packet packetOp(const Packet& a) const { return internal::pfloor(...
function EIGEN_STRONG_INLINE (line 661) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 663) | inline Packet packetOp(const Packet& a) const { return internal::pceil(a...
function result_type (line 681) | result_type operator() (const Scalar& a) const { return (numext::isnan)(...
function result_type (line 699) | result_type operator() (const Scalar& a) const { return (numext::isinf)(...
function result_type (line 717) | result_type operator() (const Scalar& a) const { return (numext::isfinit...
function const (line 735) | bool operator() (const bool& a) const { return !a; }
function EIGEN_DEVICE_FUNC (line 753) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
function EIGEN_DEVICE_FUNC (line 764) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/GeneralBlockPanelKernel.h
function namespace (line 14) | namespace Eigen {
function EIGEN_ALWAYS_INLINE (line 317) | EIGEN_ALWAYS_INLINE static void run(const CJ& cj, A& a, B& b, C& c, T& /...
function gebp_madd (line 331) | void gebp_madd(const CJ& cj, A& a, B& b, C& c, T& t)
type _RhsScalar (line 355) | typedef _RhsScalar RhsScalar;
type typename (line 356) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type typename (line 386) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 387) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 388) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 390) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 391) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 392) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 394) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 401) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function loadRhs (line 412) | void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 417) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function loadLhs (line 423) | void loadLhs(const LhsScalar* a, LhsPacketType& dest) const
function loadLhsUnaligned (line 429) | void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
function madd (line 435) | void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType&...
function EIGEN_STRONG_INLINE (line 450) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
function acc (line 456) | void acc(const ResPacketHalf& c, const ResPacketHalf& alpha, ResPacketHa...
type RealScalar (line 468) | typedef RealScalar RhsScalar;
type typename (line 469) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type typename (line 492) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 493) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 494) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 496) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 497) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 498) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 500) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 507) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 512) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function EIGEN_STRONG_INLINE (line 517) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 522) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 527) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function EIGEN_STRONG_INLINE (line 537) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Ac...
function EIGEN_STRONG_INLINE (line 542) | EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& ...
function EIGEN_STRONG_INLINE (line 552) | EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& ...
function EIGEN_STRONG_INLINE (line 557) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
type std (line 603) | typedef std::complex<RealScalar> LhsScalar;
type std (line 604) | typedef std::complex<RealScalar> RhsScalar;
type std (line 605) | typedef std::complex<RealScalar> ResScalar;
type typename (line 625) | typedef typename packet_traits<RealScalar>::type RealPacket;
type typename (line 626) | typedef typename packet_traits<Scalar>::type ScalarPacket;
type DoublePacket (line 627) | typedef DoublePacket<RealPacket> DoublePacketType;
type typename (line 629) | typedef typename conditional<Vectorizable,RealPacket, Scalar>::type Lhs...
type typename (line 630) | typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type...
type typename (line 631) | typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type Res...
type typename (line 632) | typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type...
function EIGEN_STRONG_INLINE (line 643) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, ResPacket& dest) const
function EIGEN_STRONG_INLINE (line 649) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, DoublePacketType& d...
function EIGEN_STRONG_INLINE (line 655) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, ResPacket& dest...
function EIGEN_STRONG_INLINE (line 659) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, DoublePacketTyp...
function EIGEN_STRONG_INLINE (line 665) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function EIGEN_STRONG_INLINE (line 675) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, DoublePacketTy...
function EIGEN_STRONG_INLINE (line 683) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsScalar& b0,...
function EIGEN_STRONG_INLINE (line 691) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 696) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 701) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Do...
function EIGEN_STRONG_INLINE (line 707) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Re...
function EIGEN_STRONG_INLINE (line 712) | EIGEN_STRONG_INLINE void acc(const Scalar& c, const Scalar& alpha, Scala...
function EIGEN_STRONG_INLINE (line 714) | EIGEN_STRONG_INLINE void acc(const DoublePacketType& c, const ResPacket&...
type RealScalar (line 751) | typedef RealScalar LhsScalar;
type Scalar (line 752) | typedef Scalar RhsScalar;
type Scalar (line 753) | typedef Scalar ResScalar;
type typename (line 773) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 774) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 775) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 777) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 778) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 779) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 781) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 788) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
function broadcastRhs (line 793) | void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1, RhsP...
function EIGEN_STRONG_INLINE (line 805) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 810) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function EIGEN_STRONG_INLINE (line 816) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 821) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Ac...
function EIGEN_STRONG_INLINE (line 826) | EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& ...
function EIGEN_STRONG_INLINE (line 837) | EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& ...
function EIGEN_STRONG_INLINE (line 842) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
type gebp_traits (line 861) | typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> Traits;
type typename (line 862) | typedef typename Traits::ResScalar ResScalar;
type typename (line 863) | typedef typename Traits::LhsPacket LhsPacket;
type typename (line 864) | typedef typename Traits::RhsPacket RhsPacket;
type typename (line 865) | typedef typename Traits::ResPacket ResPacket;
type typename (line 866) | typedef typename Traits::AccPacket AccPacket;
type gebp_traits (line 868) | typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs> Swapp...
type typename (line 869) | typedef typename SwappedTraits::ResScalar SResScalar;
type typename (line 870) | typedef typename SwappedTraits::LhsPacket SLhsPacket;
type typename (line 871) | typedef typename SwappedTraits::RhsPacket SRhsPacket;
type typename (line 872) | typedef typename SwappedTraits::ResPacket SResPacket;
type typename (line 873) | typedef typename SwappedTraits::AccPacket SAccPacket;
type typename (line 875) | typedef typename DataMapper::LinearMapper LinearMapper;
type typename (line 1529) | typedef typename unpacket_traits<SResPacket>::half SResPacketHalf;
type typename (line 1584) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1585) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1586) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1587) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1894) | typedef typename DataMapper::LinearMapper LinearMapper;
type typename (line 2018) | typedef typename DataMapper::LinearMapper LinearMapper;
function l1CacheSize (line 2111) | inline std::ptrdiff_t l1CacheSize()
function l2CacheSize (line 2120) | inline std::ptrdiff_t l2CacheSize()
function l3CacheSize (line 2130) | inline std::ptrdiff_t l3CacheSize()
function setCpuCacheSizes (line 2142) | inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2, std::...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/GeneralMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type typename (line 58) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type const_blas_data_mapper (line 68) | typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMap...
type blas_data_mapper (line 69) | typedef blas_data_mapper<typename
function initParallelSession (line 215) | void initParallelSession(Index num_threads) const
type typename (line 233) | typedef typename Gemm::Traits Traits;
type _LhsScalar (line 249) | typedef _LhsScalar LhsScalar;
type _RhsScalar (line 250) | typedef _RhsScalar RhsScalar;
function LhsScalar (line 270) | inline LhsScalar* blockA() { return m_blockA; }
function RhsScalar (line 271) | inline RhsScalar* blockB() { return m_blockB; }
type typename (line 285) | typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsS...
type typename (line 286) | typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsS...
type gebp_traits (line 287) | typedef gebp_traits<LhsScalar,RhsScalar> Traits;
function initParallel (line 317) | void initParallel(Index, Index, Index, Index)
function allocateA (line 320) | inline void allocateA() {}
function allocateB (line 321) | inline void allocateB() {}
function allocateAll (line 322) | inline void allocateAll() {}
type typename (line 334) | typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsS...
type typename (line 335) | typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsS...
type gebp_traits (line 336) | typedef gebp_traits<LhsScalar,RhsScalar> Traits;
function initParallel (line 363) | void initParallel(Index rows, Index cols, Index depth, Index num_threads)
function allocateA (line 376) | void allocateA()
function allocateB (line 382) | void allocateB()
function allocateAll (line 388) | void allocateAll()
function namespace (line 403) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
function namespace (line 13) | namespace Eigen {
type gebp_traits (line 139) | typedef gebp_traits<LhsScalar,RhsScalar,ConjLhs,ConjRhs> Traits;
type typename (line 140) | typedef typename Traits::ResScalar ResScalar;
type blas_data_mapper (line 147) | typedef blas_data_mapper<ResScalar, Index, ColMajor> ResMapper;
type typename (line 206) | typedef typename internal::remove_all<typename
type internal (line 207) | typedef internal::blas_traits<Lhs> LhsBlasTraits;
type typename (line 208) | typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
type typename (line 209) | typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
type typename (line 212) | typedef typename internal::remove_all<typename
type internal (line 213) | typedef internal::blas_traits<Rhs> RhsBlasTraits;
type typename (line 214) | typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
type typename (line 215) | typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
type internal (line 250) | typedef internal::blas_traits<Lhs> LhsBlasTraits;
type typename (line 251) | typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
type typename (line 252) | typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
type typename (line 255) | typedef typename internal::remove_all<typename
type internal (line 256) | typedef internal::blas_traits<Rhs> RhsBlasTraits;
type typename (line 257) | typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
type typename (line 258) | typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
type internal (line 272) | typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,t...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
function namespace (line 38) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/GeneralMatrixVector.h
function namespace (line 13) | namespace Eigen {
type typename (line 347) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 348) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 349) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 351) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 352) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 353) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type typename (line 387) | typedef typename LhsMapper::VectorMapper LhsScalars;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
function namespace (line 38) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/Parallelizer.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type gebp_traits (line 332) | typedef gebp_traits<Scalar,Scalar> Traits;
type const_blas_data_mapper (line 334) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 335) | typedef const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMaj...
type const_blas_data_mapper (line 336) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 337) | typedef blas_data_mapper<typename
type gebp_traits (line 425) | typedef gebp_traits<Scalar,Scalar> Traits;
type const_blas_data_mapper (line 427) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type blas_data_mapper (line 428) | typedef blas_data_mapper<typename
function namespace (line 466) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/SelfadjointMatrixVector.h
function namespace (line 13) | namespace Eigen {
function namespace (line 160) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/SelfadjointProduct.h
function namespace (line 19) | namespace Eigen {
type internal (line 56) | typedef internal::blas_traits<OtherType> OtherBlasTraits;
type typename (line 57) | typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
type typename (line 58) | typedef typename internal::remove_all<ActualOtherType>::type _ActualOthe...
type internal (line 88) | typedef internal::blas_traits<OtherType> OtherBlasTraits;
type typename (line 89) | typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
type typename (line 90) | typedef typename internal::remove_all<ActualOtherType>::type _ActualOthe...
type internal (line 103) | typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,S...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/SelfadjointRank2Update.h
function namespace (line 13) | namespace Eigen {
type typename (line 64) | typedef typename UBlasTraits::DirectLinearAccessType ActualUType;
type typename (line 65) | typedef typename internal::remove_all<ActualUType>::type _ActualUType;
type internal (line 68) | typedef internal::blas_traits<DerivedV> VBlasTraits;
type typename (line 69) | typedef typename VBlasTraits::DirectLinearAccessType ActualVType;
type typename (line 70) | typedef typename internal::remove_all<ActualVType>::type _ActualVType;
type typename (line 82) | typedef typename internal::remove_all<typename
type typename (line 83) | typedef typename internal::remove_all<typename
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/TriangularMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type const_blas_data_mapper (line 120) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 121) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 122) | typedef blas_data_mapper<typename
type const_blas_data_mapper (line 271) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 272) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 273) | typedef blas_data_mapper<typename
function namespace (line 390) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/TriangularMatrixVector.h
function namespace (line 13) | namespace Eigen {
type Map (line 114) | typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterSt...
function LhsMap (line 115) | const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
function namespace (line 171) | namespace internal {
function namespace (line 200) | namespace internal {
function run (line 283) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
function namespace (line 38) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/TriangularSolverMatrix.h
function namespace (line 13) | namespace Eigen {
type const_blas_data_mapper (line 56) | typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
type blas_data_mapper (line 57) | typedef blas_data_mapper<Scalar, Index, ColMajor> OtherMapper;
type gebp_traits (line 61) | typedef gebp_traits<Scalar,Scalar> Traits;
type blas_data_mapper (line 206) | typedef blas_data_mapper<Scalar, Index, ColMajor> LhsMapper;
type const_blas_data_mapper (line 207) | typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
type gebp_traits (line 211) | typedef gebp_traits<Scalar,Scalar> Traits;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
function namespace (line 38) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/products/TriangularSolverVector.h
function namespace (line 13) | namespace Eigen {
type Map (line 38) | typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterSt...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/BlasUtil.h
function namespace (line 16) | namespace Eigen {
function EIGEN_STRONG_INLINE (line 81) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 84) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
function EIGEN_STRONG_INLINE (line 91) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 94) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
function EIGEN_STRONG_INLINE (line 101) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 104) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
type std (line 110) | typedef std::complex<RealScalar> Scalar;
function EIGEN_STRONG_INLINE (line 111) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const RealScalar& y, c...
function EIGEN_STRONG_INLINE (line 113) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const RealScalar& y) const
type std (line 119) | typedef std::complex<RealScalar> Scalar;
function EIGEN_STRONG_INLINE (line 120) | EIGEN_STRONG_INLINE Scalar pmadd(const RealScalar& x, const Scalar& y, c...
function EIGEN_STRONG_INLINE (line 122) | EIGEN_STRONG_INLINE Scalar pmul(const RealScalar& x, const Scalar& y) const
function To (line 127) | To run(const From& x) { return To(x); }
function typename (line 132) | typename NumTraits<Scalar>::Real run(const Scalar& x) { return numext::r...
function m_data (line 139) | m_data(data) {}
function Scalar (line 141) | Scalar operator()(Index i) const {
function EIGEN_ALWAYS_INLINE (line 145) | EIGEN_ALWAYS_INLINE Packet load(Index i) const {
function aligned (line 150) | bool aligned(Index i) const {
type typename (line 162) | typedef typename packet_traits<Scalar>::half HalfPacket;
function m_data (line 164) | m_data(data) {}
function prefetch (line 166) | void prefetch(int i) const {
function Packet (line 174) | Packet loadPacket(Index i) const {
function HalfPacket (line 178) | HalfPacket loadHalfPacket(Index i) const {
function storePacket (line 182) | void storePacket(Index i, const Packet &p) const {
type typename (line 195) | typedef typename packet_traits<Scalar>::half HalfPacket;
type BlasLinearMapper (line 197) | typedef BlasLinearMapper<Scalar, Index, AlignmentType> LinearMapper;
type BlasVectorMapper (line 198) | typedef BlasVectorMapper<Scalar, Index> VectorMapper;
function EIGEN_DEVICE_FUNC (line 200) | EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Ind...
function LinearMapper (line 207) | LinearMapper getLinearMapper(Index i, Index j) const {
function VectorMapper (line 211) | VectorMapper getVectorMapper(Index i, Index j) const {
function Packet (line 221) | Packet loadPacket(Index i, Index j) const {
function HalfPacket (line 225) | HalfPacket loadHalfPacket(Index i, Index j) const {
function scatterPacket (line 230) | void scatterPacket(Index i, Index j, const SubPacket &p) const {
function EIGEN_ALWAYS_INLINE (line 235) | EIGEN_ALWAYS_INLINE SubPacket gatherPacket(Index i, Index j) const {
function EIGEN_DEVICE_FUNC (line 240) | EIGEN_DEVICE_FUNC const Scalar* data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 242) | EIGEN_DEVICE_FUNC Index firstAligned(Index size) const {
type typename (line 271) | typedef typename traits<XprType>::Scalar Scalar;
type XprType (line 272) | typedef const XprType& ExtractType;
type XprType (line 273) | typedef XprType _ExtractType;
type typename (line 283) | typedef typename conditional<bool(HasUsableDirectAccess),
function ExtractType (line 287) | static inline ExtractType extract(const XprType& x) { return x; }
function Scalar (line 288) | static inline const Scalar extractScalarFactor(const XprType&) { return ...
type CwiseUnaryOp (line 297) | typedef CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> XprType;
type typename (line 298) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 304) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 305) | static inline Scalar extractScalarFactor(const XprType& x) { return conj...
type CwiseBinaryOp (line 314) | typedef CwiseBinaryOp<scalar_product_op<Scalar>, const
type typename (line 315) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 316) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 317) | static inline Scalar extractScalarFactor(const XprType& x)
type CwiseBinaryOp (line 325) | typedef CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const
type typename (line 326) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 327) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 328) | static inline Scalar extractScalarFactor(const XprType& x)
type CwiseUnaryOp (line 343) | typedef CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> XprType;
type typename (line 344) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 345) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 346) | static inline Scalar extractScalarFactor(const XprType& x)
type typename (line 355) | typedef typename NestedXpr::Scalar Scalar;
type blas_traits (line 356) | typedef blas_traits<NestedXpr> Base;
type Transpose (line 357) | typedef Transpose<NestedXpr> XprType;
type Transpose (line 358) | typedef Transpose<const typename
type Transpose (line 359) | typedef Transpose<const typename
type typename (line 360) | typedef typename conditional<bool(Base::HasUsableDirectAccess),
function ExtractType (line 367) | static inline ExtractType extract(const XprType& x) { return ExtractType...
function Scalar (line 368) | static inline Scalar extractScalarFactor(const XprType& x) { return Base...
function typename (line 378) | static const typename T::Scalar* run(const T& m)
function typename (line 386) | static typename T::Scalar* run(const T&) { return 0; }
function typename (line 389) | typename T::Scalar* extract_data(const T& m)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/Constants.h
type UpLoType (line 202) | enum UpLoType {
type AlignmentType (line 227) | enum AlignmentType {
type CornerType (line 257) | enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight }
type DirectionType (line 262) | enum DirectionType {
type TraversalType (line 276) | enum TraversalType {
type UnrollingType (line 298) | enum UnrollingType {
type SpecializedType (line 310) | enum SpecializedType {
type StorageOptions (line 318) | enum StorageOptions {
type SideType (line 331) | enum SideType {
type NoChange_t (line 350) | enum NoChange_t { NoChange }
type Sequential_t (line 351) | enum Sequential_t { Sequential }
type Default_t (line 352) | enum Default_t { Default }
type AmbiVectorMode (line 356) | enum AmbiVectorMode {
type AccessorLevels (line 364) | enum AccessorLevels {
type DecompositionOptions (line 377) | enum DecompositionOptions {
type QRPreconditioners (line 413) | enum QRPreconditioners {
type ComputationInfo (line 430) | enum ComputationInfo {
type TransformTraits (line 445) | enum TransformTraits {
function namespace (line 459) | namespace Architecture
type ProductImplType (line 483) | enum ProductImplType
type Action (line 488) | enum Action {GetAction, SetAction}
type Dense (line 491) | struct Dense {}
type Sparse (line 494) | struct Sparse {}
type SolverStorage (line 497) | struct SolverStorage {}
type PermutationStorage (line 500) | struct PermutationStorage {}
type TranspositionsStorage (line 503) | struct TranspositionsStorage {}
type MatrixXpr (line 506) | struct MatrixXpr {}
type ArrayXpr (line 509) | struct ArrayXpr {}
type HomogeneousShape (line 514) | struct HomogeneousShape { static std::string debugName() { return ...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/ForwardDeclarations.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/MKL_support.h
function namespace (line 111) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/Macros.h
function namespace (line 541) | namespace Eigen {
function namespace (line 552) | namespace Eigen {
function namespace (line 610) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/Memory.h
function namespace (line 62) | namespace Eigen {
function conditional_aligned_free (line 228) | inline void conditional_aligned_free(void *ptr)
function destruct_elements_of_array (line 255) | inline void destruct_elements_of_array(T *ptr, size_t size)
function T (line 265) | inline T* construct_elements_of_array(T *ptr, size_t size)
function check_size_for_overflow (line 286) | void check_size_for_overflow(size_t size)
function T (line 296) | inline T* aligned_new(size_t size)
function T (line 312) | inline T* conditional_aligned_new(size_t size)
function aligned_delete (line 331) | inline void aligned_delete(T *ptr, size_t size)
function conditional_aligned_delete (line 340) | inline void conditional_aligned_delete(T *ptr, size_t size)
function T (line 346) | inline T* conditional_aligned_realloc_new(T* pts, size_t new_size, size_...
function T (line 369) | inline T* conditional_aligned_new_auto(size_t size)
function T (line 390) | T* conditional_aligned_realloc_new_auto(T* pts, size_t new_size, size_t ...
function conditional_aligned_delete_auto (line 412) | inline void conditional_aligned_delete_auto(T *ptr, size_t size)
function Index (line 439) | inline Index first_aligned(const Scalar* array, Index size)
function Index (line 467) | inline Index first_default_aligned(const Scalar* array, Index size)
function Index (line 476) | Index first_multiple(Index size, Index base)
function smart_copy (line 485) | void smart_copy(const T* start, const T* end, T* target)
function EIGEN_DEVICE_FUNC (line 491) | EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T...
function EIGEN_DEVICE_FUNC (line 501) | EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T...
function run (line 514) | static inline void run(const T* start, const T* end, T* target)
function run (line 524) | static inline void run(const T* start, const T* end, T* target)
function T (line 596) | const T& operator[](std::ptrdiff_t i) const { return m_ptr[i]; }
function T (line 598) | const T* ptr() const { return m_ptr; }
function operator (line 599) | operator const T*() const { return m_ptr; }
function operator (line 682) | operator delete(void *ptr, const std::nothrow_t&) EIGEN_NO_THROW { \
type eigen_aligned_operator_new_marker_type (line 685) | typedef void eigen_aligned_operator_new_marker_type;
type T (line 718) | typedef T* pointer;
type T (line 719) | typedef const T* const_pointer;
type T (line 720) | typedef T& reference;
type T (line 721) | typedef const T& const_reference;
type T (line 722) | typedef T value_type;
type aligned_allocator (line 727) | typedef aligned_allocator<U> other;
function deallocate (line 745) | void deallocate(pointer p, size_type /*num*/)
function namespace (line 776) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/Meta.h
function namespace (line 23) | namespace Eigen {
type T (line 118) | typedef const T type;
type T (line 119) | typedef T const& type;
type T (line 120) | typedef T const* type;
type T (line 121) | typedef T const* const type;
type T (line 122) | typedef T const* const type;
type any_conversion (line 129) | struct any_conversion
type yes (line 134) | struct yes {int a[1];}
type no (line 135) | struct no {int a[2];}
type T (line 165) | typedef T type;
function namespace (line 173) | namespace device {
function class (line 272) | class noncopyable
type typename (line 290) | typedef typename std::result_of<T>::type type1;
type typename (line 291) | typedef typename remove_all<type1>::type type;
type has_none (line 296) | struct has_none {int a[1];}
type has_std_result_type (line 297) | struct has_std_result_type {int a[2];}
type has_tr1_result (line 298) | struct has_tr1_result {int a[3];}
type typename (line 301) | typedef typename internal::remove_all<ArgType>::type type;
type typename (line 319) | typedef typename unary_result_of_select<Func, ArgType, FunctorType>::typ...
type typename (line 323) | typedef typename internal::remove_all<ArgType0>::type type;
type typename (line 343) | typedef typename binary_result_of_select<Func, ArgType0, ArgType1, Funct...
type typename (line 347) | typedef typename internal::remove_all<ArgType0>::type type;
type typename (line 367) | typedef typename ternary_result_of_select<Func, ArgType0, ArgType1, ArgT...
type meta_yes (line 371) | struct meta_yes { char a[1]; }
type meta_no (line 372) | struct meta_no { char a[2]; }
function meta_yes (line 389) | meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>(...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/StaticAssert.h
function namespace (line 36) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Core/util/XprHelper.h
function namespace (line 25) | namespace Eigen {
function class (line 89) | class no_assignment_operator
function EIGEN_STRONG_INLINE (line 110) | EIGEN_STRONG_INLINE explicit variable_if_dynamic(T v) { EIGEN_ONLY_USED_...
function T (line 111) | T value() { return T(Value); }
function setValue (line 112) | void setValue(T) {}
function EIGEN_DEVICE_FUNC (line 118) | EIGEN_DEVICE_FUNC variable_if_dynamic() { eigen_assert(false); }
function explicit (line 120) | explicit variable_if_dynamic(T value) : m_value(value) {}
function setValue (line 122) | void setValue(T value) { m_value = value; }
function EIGEN_STRONG_INLINE (line 131) | EIGEN_STRONG_INLINE explicit variable_if_dynamicindex(T v) { EIGEN_ONLY_...
function T (line 132) | T value() { return T(Value); }
function setValue (line 133) | void setValue(T) {}
function EIGEN_DEVICE_FUNC (line 139) | EIGEN_DEVICE_FUNC variable_if_dynamicindex() { eigen_assert(false); }
function explicit (line 141) | explicit variable_if_dynamicindex(T value) : m_value(value) {}
function setValue (line 143) | void setValue(T value) { m_value = value; }
type T (line 160) | typedef T type;
type T (line 161) | typedef T half;
type typename (line 188) | typedef typename find_best_packet_helper<Size,typename
type typename (line 279) | typedef typename plain_matrix_type_dense<T,typename
type typename (line 283) | typedef typename T::PlainObject type;
type typename (line 316) | typedef typename plain_matrix_type<T>::type type;
type typename (line 329) | typedef typename plain_matrix_type<T>::type type;
type typename (line 352) | typedef typename plain_matrix_type_dense<T,typename
type Matrix (line 365) | typedef Matrix<typename
type Matrix (line 383) | typedef Matrix<typename
type typename (line 398) | typedef typename conditional<
type typename (line 404) | typedef typename conditional<
type typename (line 415) | typedef typename conditional<
type typename (line 452) | typedef typename conditional<Evaluate, PlainObject, typename
function T (line 457) | inline T* const_cast_ptr(const T* ptr)
type typename (line 491) | typedef typename XprType::Scalar CurrentScalarType;
type typename (line 492) | typedef typename remove_all<CastType>::type _CastType;
type typename (line 493) | typedef typename _CastType::Scalar NewScalarType;
type typename (line 494) | typedef typename conditional<is_same<CurrentScalarType,NewScalarType>::v...
type A (line 502) | typedef A ret;
type A (line 506) | typedef A ret;
type A (line 510) | typedef A ret;
type Matrix (line 572) | typedef Matrix<Scalar, 1, ExpressionType::ColsAtCompileTime,
type Array (line 574) | typedef Array<Scalar, 1, ExpressionType::ColsAtCompileTime,
type typename (line 577) | typedef typename conditional<
type Matrix (line 587) | typedef Matrix<Scalar, ExpressionType::RowsAtCompileTime, 1,
type Array (line 589) | typedef Array<Scalar, ExpressionType::RowsAtCompileTime, 1,
type typename (line 592) | typedef typename conditional<
type Matrix (line 605) | typedef Matrix<Scalar, diag_size, 1, ExpressionType::PlainObject::Options
type Array (line 606) | typedef Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options
type typename (line 608) | typedef typename conditional<
type Array (line 620) | typedef Array<Scalar, traits<Expr>::RowsAtCompileTime, traits<Expr>::...
type Matrix (line 623) | typedef Matrix<Scalar, traits<Expr>::RowsAtCompileTime, traits<Expr>:...
type CwiseNullaryOp (line 626) | typedef CwiseNullaryOp<scalar_constant_op<Scalar>, const
type glue_shapes (line 649) | struct glue_shapes
type TriangularShape (line 649) | typedef TriangularShape type;
type ScalarBinaryOpTraits (line 757) | struct ScalarBinaryOpTraits
type T (line 767) | typedef T ReturnType;
type T (line 773) | typedef T ReturnType;
type T (line 778) | typedef T ReturnType;
type T (line 785) | typedef T ReturnType;
type T (line 792) | typedef T ReturnType;
type ReturnType (line 799) | typedef void ReturnType;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/ComplexEigenSolver.h
function namespace (line 17) | namespace Eigen {
function EigenvalueType (line 182) | const EigenvalueType& eigenvalues() const
function Index (line 233) | Index getMaxIterations()
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/ComplexSchur.h
function namespace (line 17) | namespace Eigen {
function ComplexMatrixType (line 162) | const ComplexMatrixType& matrixT() const
function Index (line 235) | Index getMaxIterations()
function namespace (line 349) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/EigenSolver.h
function namespace (line 16) | namespace Eigen {
function EigenvalueType (line 244) | const EigenvalueType& eigenvalues() const
function Index (line 295) | Index getMaxIterations()
type Matrix (line 319) | typedef Matrix<Scalar, ColsAtCompileTime, 1, Options
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
function namespace (line 17) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
function namespace (line 16) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/HessenbergDecomposition.h
function namespace (line 14) | namespace Eigen {
function CoeffVectorType (line 179) | const CoeffVectorType& householderCoefficients() const
type typename (line 271) | typedef typename NumTraits<Scalar>::Real RealScalar;
function namespace (line 322) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/RealQZ.h
function namespace (line 13) | namespace Eigen {
function MatrixType (line 139) | const MatrixType& matrixS() const {
type Matrix (line 200) | typedef Matrix<Scalar,3,1> Vector3s;
type Matrix (line 201) | typedef Matrix<Scalar,2,1> Vector2s;
type Matrix (line 202) | typedef Matrix<Scalar,2,2> Matrix2s;
type JacobiRotation (line 203) | typedef JacobiRotation<Scalar> JRs;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/RealSchur.h
function namespace (line 16) | namespace Eigen {
function MatrixType (line 144) | const MatrixType& matrixT() const
function Index (line 213) | Index getMaxIterations()
type Matrix (line 236) | typedef Matrix<Scalar,3,1> Vector3s;
function typename (line 341) | typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT()
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
function namespace (line 16) | namespace Eigen {
function namespace (line 370) | namespace internal {
function namespace (line 468) | namespace internal {
type typename (line 714) | typedef typename SolverType::RealVectorType VectorType;
type typename (line 715) | typedef typename SolverType::Scalar Scalar;
type typename (line 716) | typedef typename SolverType::EigenvectorsType EigenvectorsType;
function EIGEN_DEVICE_FUNC (line 718) | EIGEN_DEVICE_FUNC
function namespace (line 804) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Eigenvalues/Tridiagonalization.h
function namespace (line 14) | namespace Eigen {
function namespace (line 321) | namespace internal {
type typename (line 439) | typedef typename Tridiagonalization<MatrixType>::CoeffVectorType CoeffVe...
type typename (line 440) | typedef typename Tridiagonalization<MatrixType>::HouseholderSequenceType...
type typename (line 463) | typedef typename MatrixType::RealScalar RealScalar;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/AlignedBox.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 146) | EIGEN_DEVICE_FUNC inline VectorType corner(CornerType corner) const
function EIGEN_DEVICE_FUNC (line 164) | EIGEN_DEVICE_FUNC inline VectorType sample() const
function contains (line 182) | inline bool contains(const MatrixBase<Derived>& p) const
function EIGEN_DEVICE_FUNC (line 189) | EIGEN_DEVICE_FUNC inline bool contains(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 194) | EIGEN_DEVICE_FUNC inline bool intersects(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 210) | EIGEN_DEVICE_FUNC inline AlignedBox& extend(const AlignedBox& b)
function EIGEN_DEVICE_FUNC (line 220) | EIGEN_DEVICE_FUNC inline AlignedBox& clamp(const AlignedBox& b)
function EIGEN_DEVICE_FUNC (line 230) | EIGEN_DEVICE_FUNC inline AlignedBox intersection(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 236) | EIGEN_DEVICE_FUNC inline AlignedBox merged(const AlignedBox& b) const
function NonInteger (line 267) | inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const AlignedBox& b...
function explicit (line 292) | inline explicit AlignedBox(const AlignedBox<OtherScalarType,AmbientDimAt...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/AngleAxis.h
function namespace (line 13) | namespace Eigen {
function explicit (line 139) | inline explicit AngleAxis(const AngleAxis<OtherScalarType>& other)
function EIGEN_DEVICE_FUNC (line 145) | EIGEN_DEVICE_FUNC static inline const AngleAxis Identity() { return Angl...
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC bool isApprox(const AngleAxis& other, const typename N...
type AngleAxis (line 157) | typedef AngleAxis<float> AngleAxisf;
type AngleAxis (line 160) | typedef AngleAxis<double> AngleAxisd;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/EulerAngles.h
function namespace (line 13) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/Homogeneous.h
function namespace (line 13) | namespace Eigen {
type MatrixBase (line 68) | typedef MatrixBase<Homogeneous> Base;
function explicit (line 71) | explicit inline Homogeneous(const MatrixType& matrix)
function EIGEN_DEVICE_FUNC (line 299) | EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, ...
type HomogeneousShape (line 325) | typedef HomogeneousShape Shape;
type AssignmentKind (line 328) | struct AssignmentKind
type Dense2Dense (line 328) | typedef Dense2Dense Kind;
type typename (line 336) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 337) | typedef evaluator<PlainObject> Base;
function EIGEN_DEVICE_FUNC (line 339) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
type Homogeneous (line 370) | typedef Homogeneous<ArgType,Horizontal> SrcXprType;
type typename (line 400) | typedef typename Rhs::template
type typename (line 401) | typedef typename remove_const<LinearBlockConst>::type Li...
type typename (line 402) | typedef typename Rhs::ConstRowXpr Co...
type Replicate (line 403) | typedef Replicate<const ConstantColumn,Rows,1> Co...
type Product (line 404) | typedef Product<Lhs,LinearBlock,LazyProduct> Li...
type CwiseBinaryOp (line 405) | typedef CwiseBinaryOp<internal::scalar_sum_op<typename
type homogeneous_right_product_refactoring_helper (line 413) | typedef homogeneous_right_product_refactoring_helper<typename
type typename (line 414) | typedef typename helper::ConstantBlock ConstantBlock;
type typename (line 415) | typedef typename helper::Xpr RefactoredXpr;
type evaluator (line 416) | typedef evaluator<RefactoredXpr> Base;
function EIGEN_DEVICE_FUNC (line 418) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
type typename (line 453) | typedef typename Lhs::template
type typename (line 454) | typedef typename remove_const<LinearBlockConst>::type Li...
type typename (line 455) | typedef typename Lhs::ConstColXpr Co...
type Replicate (line 456) | typedef Replicate<const ConstantColumn,1,Cols> Co...
type Product (line 457) | typedef Product<LinearBlock,Rhs,LazyProduct> Li...
type CwiseBinaryOp (line 458) | typedef CwiseBinaryOp<internal::scalar_sum_op<typename
type homogeneous_left_product_refactoring_helper (line 466) | typedef homogeneous_left_product_refactoring_helper<Lhs,typename
type typename (line 467) | typedef typename helper::ConstantBlock ConstantBlock;
type typename (line 468) | typedef typename helper::Xpr RefactoredXpr;
type evaluator (line 469) | typedef evaluator<RefactoredXpr> Base;
function EIGEN_DEVICE_FUNC (line 471) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function evalTo (line 482) | static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneou...
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/Hyperplane.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/OrthoMethods.h
function namespace (line 14) | namespace Eigen {
function namespace (line 50) | namespace internal {
type typename (line 87) | typedef typename internal::nested_eval<Derived,2>::type DerivedNested;
type typename (line 88) | typedef typename internal::nested_eval<OtherDerived,2>::type OtherDerive...
function namespace (line 137) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/ParametrizedLine.h
function namespace (line 14) | namespace Eigen {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/Quaternion.h
function namespace (line 13) | namespace Eigen {
type Quaternion (line 302) | typedef Quaternion<float> Quaternionf;
type Quaternion (line 305) | typedef Quaternion<double> Quaterniond;
function namespace (line 311) | namespace internal {
function namespace (line 319) | namespace internal {
type _Scalar (line 349) | typedef _Scalar Scalar;
type typename (line 350) | typedef typename internal::traits<Map>::Coefficients Coefficients;
function EIGEN_STRONG_INLINE (line 360) | EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {}
type _Scalar (line 386) | typedef _Scalar Scalar;
type typename (line 387) | typedef typename internal::traits<Map>::Coefficients Coefficients;
function EIGEN_STRONG_INLINE (line 397) | EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {}
function EIGEN_DEVICE_FUNC (line 399) | EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
type Map (line 408) | typedef Map<Quaternion<float>, 0> QuaternionMapf;
type Map (line 411) | typedef Map<Quaternion<double>, 0> QuaternionMapd;
type Map (line 414) | typedef Map<Quaternion<float>, Aligned> QuaternionMapAlignedf;
type Map (line 417) | typedef Map<Quaternion<double>, Aligned> QuaternionMapAlignedd;
function namespace (line 425) | namespace internal {
function typename (line 531) | inline typename QuaternionBase<Derived>::Matrix3
function namespace (line 674) | namespace internal {
function typename (line 704) | inline typename internal::traits<Derived>::Scalar
function namespace (line 753) | namespace internal {
function run (line 801) | static inline void run(QuaternionBase<Derived>& q, const Other& vec)
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/Rotation2D.h
function namespace (line 13) | namespace Eigen {
function explicit (line 147) | inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
function EIGEN_DEVICE_FUNC (line 152) | EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2...
function EIGEN_DEVICE_FUNC (line 158) | EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename ...
type Rotation2D (line 165) | typedef Rotation2D<float> Rotation2Df;
type Rotation2D (line 168) | typedef Rotation2D<double> Rotation2Dd;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/RotationBase.h
function namespace (line 13) | namespace Eigen {
function VectorType (line 93) | inline VectorType _transformVector(const OtherVectorType& v) const
function namespace (line 97) | namespace internal {
function EIGEN_DEVICE_FUNC (line 113) | EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r,...
type Matrix (line 125) | typedef Matrix<typename
function ReturnType (line 126) | ReturnType run(const RotationDerived& r, const OtherVectorType& v)
function namespace (line 161) | namespace internal {
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/Scaling.h
function explicit (line 48) | explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
function Scalar (line 51) | inline Scalar& factor() { return m_factor; }
function UniformScaling (line 54) | inline UniformScaling operator* (const UniformScaling& other) const
function typename (line 73) | typename internal::plain_matrix_type<Derived>::type operator* (const Mat...
function UniformScaling (line 81) | inline UniformScaling inverse() const
type DiagonalMatrix (line 146) | typedef DiagonalMatrix<float, 2> AlignedScaling2f;
type DiagonalMatrix (line 148) | typedef DiagonalMatrix<double,2> AlignedScaling2d;
type DiagonalMatrix (line 150) | typedef DiagonalMatrix<float, 3> AlignedScaling3f;
type DiagonalMatrix (line 152) | typedef DiagonalMatrix<double,3> AlignedScaling3d;
FILE: arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/src/Geometry/Transform.h
function namespace (line 15) | namespace Eigen {
type _Scalar (line 213) | typedef _Scalar Scalar;
type Eigen (line 214) | typedef Eigen::Index StorageIndex;
type Eigen (line 215) | typedef Eigen::Index Index;
type typename (line 217) | typedef typename internal::make_proper_matrix_type<Scalar,Rows,HDim,Opti...
type MatrixType (line 219) | typedef const MatrixType ConstMatrixType;
type Matrix (line 221) | typedef Matrix<Scalar,Dim,Dim,Options> LinearMatrixType;
type Block (line 223) | typedef Block<MatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (Options&...
type Block (line 225) | typedef const Block<ConstMatrixType,Dim,Dim,int(Mode)==(AffineCompact) &...
type typename (line 227) | typedef typename internal::conditional<int(Mode)==int(AffineCompact),
type typename (line 231) | typedef typename internal::conditional<int(Mode)==int(AffineCompact),
type Matrix (line 235) | typedef Matrix<Scalar,Dim,1> VectorType;
type Block (line 237) | typedef Block<MatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & R...
type Block (line 239) | typedef const Block<ConstMatrixType,Dim,1,!(internal::traits<MatrixType>...
type Translation (line 241) | typedef Translation<Scalar,Dim> TranslationType;
type Transform (line 246) | typedef Transform<Scalar,Dim,TransformTimeDiagonalMode> TransformTimeDia...
function EIGEN_DEVICE_FUNC (line 262) | EIGEN_DEVICE_FUNC inline Transform(const Transform& other)
function EIGEN_DEVICE_FUNC (line 268) | EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t)
function EIGEN_DEVICE_FUNC (line 273) | EIGEN_DEVICE_FUNC inline explicit Transform(const UniformScaling<Scalar>...
function explicit (line 279) | inline explicit Transform(const RotationBase<Derived, Dim>& r)
type internal (line 288) | typedef internal::transform_take_affine_part<Transform> take_affine_part;
function explicit (line 292) | inline explicit Transform(const EigenBase<OtherDerived>& other)
type typename (line 348) | typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixTyp...
function EIGEN_DEVICE_FUNC (line 389) | EIGEN_DEVICE_FUNC inline Scalar operator() (Index row, Index col) const ...
function EIGEN_DEVICE_FUNC (line 392) | EIGEN_DEVICE_FUNC inline Scalar& operator() (Index row, Index col) { ret...
function EIGEN_DEVICE_FUNC (line 397) | EIGEN_DEVICE_FUNC inline MatrixType& matrix() { return m_matrix; }
function EIGEN_DEVICE_FUNC (line 402) | EIGEN_DEVICE_FUNC inline LinearPart linear() { return LinearPart(m_matri...
function EIGEN_DEVICE_FUNC (line 405) | EIGEN_DEVICE_FUNC inline ConstAffinePart affine() const { return take_af...
type internal (line 509) | typedef internal::transform_transform_product_impl<Transform,Transform<S...
type typename (line 510) | typedef typename ProductType::ResultType ResultType;
type typename (line 519) | typedef typename icc_11_workaround<OtherMode,OtherOptions>::ProductType ...
function EIGEN_DEVICE_FUNC (line 533) | EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
function EIGEN_DEVICE_FUNC (line 539) | EIGEN_DEVICE_FUNC static const Transform Identity()
function Scalar (line 622) | const Scalar* data() const { return m_matrix.data(); }
function EIGEN_DEVICE_FUNC (line 624) | EIGEN_DEVICE_FUNC Scalar* data() { return m_matrix.data(); }
function explicit (line 637) | inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Optio...
function EIGEN_DEVICE_FUNC (line 647) | EIGEN_DEVICE_FUNC bool isApprox(const Transform& other, const typename N...
function EIGEN_DEVICE_FUNC (line 652) | EIGEN_DEVICE_FUNC void makeAffine()
function check_template_params (line 690) | void check_template_params()
function else (line 917) | else
function namespace (line 1140) | namespace internal {
function namespace (line 1231) | namespace internal {
function MatrixType (line 1251) | static inline const MatrixType& run(const MatrixType& m) { return m; }
function EIGEN_STRONG_INLINE (line 1315) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1331) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1333) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1357) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1359) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1382) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1384) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1404) | typedef typename TransformType::MatrixType MatrixType;
type Transform (line 1405) | typedef Transform<typename
function ResultType (line 1406) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1415) | typedef typename TransformType::MatrixType MatrixType;
type Transform (line 1416) | typedef Transform<typename
Copy disabled (too large)
Download .json
Condensed preview — 1621 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (28,231K chars).
[
{
"path": ".github/workflows/arduino_ci.yml",
"chars": 436,
"preview": "name: Arduino_CI\n\non:\n push:\n branches: [ master, develop ]\n pull_request:\n branches: [ master, develop ]\n\njobs:"
},
{
"path": ".gitignore",
"chars": 254,
"preview": "# Compiled Object files\n*.slo\n*.lo\n*.o\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled Dynamic libraries\n*.so\n*.dylib\n*.d"
},
{
"path": ".project",
"chars": 199,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<projectDescription>\n\t<name>OpenCR</name>\n\t<comment></comment>\n\t<projects>\n\t</pro"
},
{
"path": "49-stlinkv2.rules",
"chars": 107,
"preview": "SUBSYSTEMS==\"usb\", ATTRS{idVendor}==\"0483\", ATTRS{idProduct}==\"3748\", MODE:=\"0666\", SYMLINK+=\"stlinkv2_%n\"\n"
},
{
"path": "99-opencr-cdc.rules",
"chars": 516,
"preview": "#http://linux-tips.org/t/prevent-modem-manager-to-capture-usb-serial-devices/284/2.\n\n#cp rules /etc/udev/rules.d/\n#sudo "
},
{
"path": "LICENSE",
"chars": 11357,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "README.md",
"chars": 2510,
"preview": "# OpenCR: Open Source Control Module for ROS [![Build Status](https://travis-ci.org/ROBOTIS-GIT/OpenCR.svg?branch=master"
},
{
"path": "arduino/opencr_arduino/opencr/.gitignore",
"chars": 8,
"preview": ".vscode\n"
},
{
"path": "arduino/opencr_arduino/opencr/boards.txt",
"chars": 1200,
"preview": "# OpenCR Boards\n#\nmenu.device_variant=Variant\nmenu.bootloader_version=Bootloader version\nmenu.upload_method=Upload metho"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Arduino.h",
"chars": 2549,
"preview": "/*\n Arduino.h - Main include file for the Arduino SDK\n Copyright (c) 2005-2013 Arduino Team. All right reserved.\n\n T"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Client.h",
"chars": 1529,
"preview": "/*\n Client.h - Base class that provides Client\n Copyright (c) 2011 Adrian McEwen. All right reserved.\n\n This library"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/HardwareSerial.h",
"chars": 1349,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/HardwareTimer.cpp",
"chars": 2233,
"preview": "/******************************************************************************\n * The MIT License\n *\n * Copyright (c) 2"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/HardwareTimer.h",
"chars": 1729,
"preview": "/******************************************************************************\n * The MIT License\n *\n * Copyright (c) 2"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/IPAddress.cpp",
"chars": 2851,
"preview": "/*\n IPAddress.cpp - Base class that provides IPAddress\n Copyright (c) 2011 Adrian McEwen. All right reserved.\n\n This"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/IPAddress.h",
"chars": 2861,
"preview": "/*\n IPAddress.h - Base class that provides IPAddress\n Copyright (c) 2011 Adrian McEwen. All right reserved.\n\n This l"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Print.cpp",
"chars": 6090,
"preview": "/*\r\n Print.cpp - Base class that provides print() and println()\r\n Copyright (c) 2008 David A. Mellis. All right reserve"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Print.h",
"chars": 2670,
"preview": "/*\n Print.h - Base class that provides print() and println()\n Copyright (c) 2008 David A. Mellis. All right reserved."
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Printable.h",
"chars": 1335,
"preview": "/*\n Printable.h - Interface class that allows printing of complex types\n Copyright (c) 2011 Adrian McEwen. All right "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Reset.h",
"chars": 956,
"preview": "/*\n Copyright (c) 2012 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/RingBuffer.cpp",
"chars": 1440,
"preview": "/*\r\n Copyright (c) 2011 Arduino. All right reserved.\r\n\r\n This library is free software; you can redistribute it and/o"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/RingBuffer.h",
"chars": 1419,
"preview": "/*\r\n Copyright (c) 2011 Arduino. All right reserved.\r\n\r\n This library is free software; you can redistribute it and/o"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Server.h",
"chars": 963,
"preview": "/*\n Server.h - Base class that provides Server\n Copyright (c) 2011 Adrian McEwen. All right reserved.\n\n This library"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Stream.cpp",
"chars": 9002,
"preview": "/*\r\n Stream.cpp - adds parsing methods to Stream class\r\n Copyright (c) 2008 David A. Mellis. All right reserved.\r\n\r\n Th"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Stream.h",
"chars": 5054,
"preview": "/*\n Stream.h - base class for character-based streams.\n Copyright (c) 2010 David A. Mellis. All right reserved.\n\n Th"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Tone.cpp",
"chars": 3491,
"preview": "/* Tone.cpp\r\n\r\n A Tone Generator Library\r\n\r\n Written by Brett Hagman\r\n\r\n This library is free software; you can redis"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Tone.h",
"chars": 854,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/UARTClass.cpp",
"chars": 6848,
"preview": "/*\r\n Copyright (c) 2011 Arduino. All right reserved.\r\n\r\n This library is free software; you can redistribute it and/o"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/UARTClass.h",
"chars": 3267,
"preview": "/*\r\n Copyright (c) 2011 Arduino. All right reserved.\r\n\r\n This library is free software; you can redistribute it and/o"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/USBSerial.cpp",
"chars": 3362,
"preview": "/****************************************************************************\r\n *\r\n * USBSerial core library for Arduino"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/USBSerial.h",
"chars": 2264,
"preview": "/****************************************************************************\n *\n * USBSerial core library for Arduino S"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/Udp.h",
"chars": 4180,
"preview": "/*\n * Udp.cpp: Library to send/receive UDP packets.\n *\n * NOTE: UDP is fast, but has some important limitations (thanks"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/WCharacter.h",
"chars": 4769,
"preview": "/*\n WCharacter.h - Character utility functions for Wiring & Arduino\n Copyright (c) 2010 Hernando Barragan. All right re"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/WInterrupts.c",
"chars": 1367,
"preview": "/*\n Copyright (c) 2014 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/WInterrupts.h",
"chars": 1080,
"preview": "/*\n Copyright (c) 2011-2012 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/WMath.cpp",
"chars": 1538,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/WMath.h",
"chars": 1147,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/WString.cpp",
"chars": 16880,
"preview": "/*\n WString.cpp - String library for Wiring & Arduino\n ...mostly rewritten by Paul Stoffregen...\n Copyright (c) 2009-"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/WString.h",
"chars": 9603,
"preview": "/*\n WString.h - String library for Wiring & Arduino\n ...mostly rewritten by Paul Stoffregen...\n Copyright (c) 2009-10"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/avr/dtostrf.c",
"chars": 1202,
"preview": "/*\n dtostrf - Emulation for dtostrf function from avr-libc\n Copyright (c) 2013 Arduino. All rights reserved.\n Writte"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/avr/dtostrf.h",
"chars": 1038,
"preview": "/*\n dtostrf - Emulation for dtostrf function from avr-libc\n Copyright (c) 2013 Arduino. All rights reserved.\n Writte"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/avr/interrupt.h",
"chars": 0,
"preview": ""
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/avr/pgmspace.h",
"chars": 1441,
"preview": "#ifndef __PGMSPACE_H_\n#define __PGMSPACE_H_ 1\n\n#include <inttypes.h>\n\n#define PROGMEM\n#define PGM_P const char *\n#defin"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/binary.h",
"chars": 11214,
"preview": "/*\n binary.h - Definitions for binary constants\n Copyright (c) 2006 David A. Mellis. All right reserved.\n\n This libr"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/digitalWriteFast.h",
"chars": 2232,
"preview": "/*\n digitalWriteFast.h - A faster digitalWrite and digitalRead\n ...based partially on digitalWrite fast code by Paul S"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/itoa.c",
"chars": 2264,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/itoa.h",
"chars": 1266,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/new.cpp",
"chars": 1028,
"preview": "/*\n Copyright (c) 2014 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/syscalls.h",
"chars": 1731,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring.c",
"chars": 1231,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring.h",
"chars": 2590,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n Copyright (c) 2013 by Paul Stoffregen <paul@pjrc.com> (delayMicr"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_analog.c",
"chars": 2308,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n This library is free software; you can redistribute it and/or\n"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_analog.h",
"chars": 2385,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_constants.h",
"chars": 3028,
"preview": "/*\r\n Copyright (c) 2011 Arduino. All right reserved.\r\n\r\n This library is free software; you can redistribute it and/o"
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_digital.c",
"chars": 5190,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_digital.h",
"chars": 2729,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_private.h",
"chars": 1083,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_pulse.c",
"chars": 2244,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_pulse.h",
"chars": 1307,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_shift.c",
"chars": 1723,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/wiring_shift.h",
"chars": 1157,
"preview": "/*\n Copyright (c) 2011 Arduino. All right reserved.\n\n This library is free software; you can redistribute it and/or\n "
},
{
"path": "arduino/opencr_arduino/opencr/cores/arduino/yield.cpp",
"chars": 76,
"preview": "#include <Arduino.h>\n\n\nvoid yield(void)\n{\n //TODO : code implementations\n};"
},
{
"path": "arduino/opencr_arduino/opencr/keywords.txt",
"chars": 246,
"preview": "# OpenCR specific functions\nSerial4\tKEYWORD1\nprintf\tKEYWORD2\nflushRx\tKEYWORD2\ngetBaudRate\tKEYWORD2\ngetRxCnt\tKEYWORD2\nget"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_GFX.cpp",
"chars": 43408,
"preview": "/*\nThis is the core graphics library for all our displays, providing a common\nset of graphics primitives (points, lines,"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_GFX.h",
"chars": 7554,
"preview": "#ifndef _ADAFRUIT_GFX_H\n#define _ADAFRUIT_GFX_H\n\n#if ARDUINO >= 100\n #include \"Arduino.h\"\n #include \"Print.h\"\n#else\n #in"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_SPITFT.cpp",
"chars": 8714,
"preview": "/***************************************************\n This is our library for generic SPI TFT Displays with\n address w"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_SPITFT.h",
"chars": 2703,
"preview": "\n#ifndef _ADAFRUIT_SPITFT_\n#define _ADAFRUIT_SPITFT_\n\n\n#if ARDUINO >= 100\n #include \"Arduino.h\"\n #include \"Print.h\"\n#els"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Adafruit_SPITFT_Macros.h",
"chars": 4608,
"preview": "\n/*\n * Control Pins\n * */\n\n#ifdef USE_FAST_PINIO\n#define SPI_DC_HIGH() *dcport |= dcpinmask\n#define SPI_DC_LO"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMono12pt7b.h",
"chars": 14395,
"preview": "const uint8_t FreeMono12pt7bBitmaps[] PROGMEM = {\n 0x49, 0x24, 0x92, 0x48, 0x01, 0xF8, 0xE7, 0xE7, 0x67, 0x42, 0x42, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMono18pt7b.h",
"chars": 24441,
"preview": "const uint8_t FreeMono18pt7bBitmaps[] PROGMEM = {\n 0x27, 0x77, 0x77, 0x77, 0x77, 0x22, 0x22, 0x20, 0x00, 0x6F, 0xF6, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMono24pt7b.h",
"chars": 40283,
"preview": "const uint8_t FreeMono24pt7bBitmaps[] PROGMEM = {\n 0x73, 0x9C, 0xE7, 0x39, 0xCE, 0x73, 0x9C, 0xE7, 0x10, 0x84, 0x21, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMono9pt7b.h",
"chars": 10592,
"preview": "const uint8_t FreeMono9pt7bBitmaps[] PROGMEM = {\n 0xAA, 0xA8, 0x0C, 0xED, 0x24, 0x92, 0x48, 0x24, 0x48, 0x91, 0x2F, 0xE"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoBold12pt7b.h",
"chars": 16081,
"preview": "const uint8_t FreeMonoBold12pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xFF, 0xF6, 0x66, 0x60, 0x6F, 0x60, 0xE7, 0xE7, 0x62"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoBold18pt7b.h",
"chars": 28925,
"preview": "const uint8_t FreeMonoBold18pt7bBitmaps[] PROGMEM = {\n 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0x9C, 0xE7, 0x39, 0xC4, 0x03"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoBold24pt7b.h",
"chars": 47327,
"preview": "const uint8_t FreeMonoBold24pt7bBitmaps[] PROGMEM = {\n 0x38, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xF3, 0xE7"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoBold9pt7b.h",
"chars": 11574,
"preview": "const uint8_t FreeMonoBold9pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xD2, 0x1F, 0x80, 0xEC, 0x89, 0x12, 0x24, 0x40, 0x36,"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoBoldOblique12pt7b.h",
"chars": 17570,
"preview": "const uint8_t FreeMonoBoldOblique12pt7bBitmaps[] PROGMEM = {\n 0x1C, 0xF3, 0xCE, 0x38, 0xE7, 0x1C, 0x61, 0x86, 0x00, 0x6"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoBoldOblique18pt7b.h",
"chars": 31692,
"preview": "const uint8_t FreeMonoBoldOblique18pt7bBitmaps[] PROGMEM = {\n 0x0F, 0x07, 0xC7, 0xE3, 0xF1, 0xF0, 0xF8, 0xFC, 0x7C, 0x3"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoBoldOblique24pt7b.h",
"chars": 52530,
"preview": "const uint8_t FreeMonoBoldOblique24pt7bBitmaps[] PROGMEM = {\n 0x01, 0xE0, 0x3F, 0x07, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoBoldOblique9pt7b.h",
"chars": 12639,
"preview": "const uint8_t FreeMonoBoldOblique9pt7bBitmaps[] PROGMEM = {\n 0x39, 0xCC, 0x67, 0x31, 0x8C, 0x07, 0x38, 0x6C, 0xD9, 0x36"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoOblique12pt7b.h",
"chars": 15954,
"preview": "const uint8_t FreeMonoOblique12pt7bBitmaps[] PROGMEM = {\n 0x11, 0x11, 0x12, 0x22, 0x22, 0x00, 0x0E, 0xE0, 0xE7, 0xE7, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoOblique18pt7b.h",
"chars": 27096,
"preview": "const uint8_t FreeMonoOblique18pt7bBitmaps[] PROGMEM = {\n 0x00, 0x1C, 0x38, 0x70, 0xC1, 0x83, 0x06, 0x18, 0x30, 0x60, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoOblique24pt7b.h",
"chars": 45214,
"preview": "const uint8_t FreeMonoOblique24pt7bBitmaps[] PROGMEM = {\n 0x01, 0xC0, 0xF0, 0x3C, 0x0E, 0x03, 0x81, 0xE0, 0x78, 0x1C, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeMonoOblique9pt7b.h",
"chars": 11477,
"preview": "const uint8_t FreeMonoOblique9pt7bBitmaps[] PROGMEM = {\n 0x11, 0x22, 0x24, 0x40, 0x00, 0xC0, 0xDE, 0xE5, 0x29, 0x00, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSans12pt7b.h",
"chars": 17535,
"preview": "const uint8_t FreeSans12pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0xCF, 0x3C, 0xF3, 0x8A, 0x20, 0x06, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSans18pt7b.h",
"chars": 31039,
"preview": "const uint8_t FreeSans18pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE9, 0x20, 0x3F, 0xFC, 0xE3, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSans24pt7b.h",
"chars": 51419,
"preview": "const uint8_t FreeSans24pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x76, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSans9pt7b.h",
"chars": 12478,
"preview": "const uint8_t FreeSans9pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xF8, 0xC0, 0xDE, 0xF7, 0x20, 0x09, 0x86, 0x41, 0x91, 0xF"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansBold12pt7b.h",
"chars": 18893,
"preview": "const uint8_t FreeSansBold12pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xFF, 0xFF, 0x76, 0x66, 0x60, 0xFF, 0xF0, 0xF3, 0xFC"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansBold18pt7b.h",
"chars": 33181,
"preview": "const uint8_t FreeSansBold18pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xE7, 0x39, 0xCE, 0x73"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansBold24pt7b.h",
"chars": 55627,
"preview": "const uint8_t FreeSansBold24pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansBold9pt7b.h",
"chars": 12992,
"preview": "const uint8_t FreeSansBold9pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFF, 0xFE, 0x48, 0x7E, 0xEF, 0xDF, 0xBF, 0x74, 0x40, 0x19,"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansBoldOblique12pt7b.h",
"chars": 21080,
"preview": "const uint8_t FreeSansBoldOblique12pt7bBitmaps[] PROGMEM = {\n 0x1C, 0x3C, 0x78, 0xE1, 0xC3, 0x8F, 0x1C, 0x38, 0x70, 0xC"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansBoldOblique18pt7b.h",
"chars": 37952,
"preview": "const uint8_t FreeSansBoldOblique18pt7bBitmaps[] PROGMEM = {\n 0x06, 0x01, 0xC0, 0x7C, 0x1F, 0x0F, 0xC3, 0xE0, 0xF8, 0x3"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansBoldOblique24pt7b.h",
"chars": 63705,
"preview": "const uint8_t FreeSansBoldOblique24pt7bBitmaps[] PROGMEM = {\n 0x01, 0xE0, 0x07, 0xF0, 0x1F, 0xC0, 0xFF, 0x03, 0xF8, 0x0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansBoldOblique9pt7b.h",
"chars": 14469,
"preview": "const uint8_t FreeSansBoldOblique9pt7bBitmaps[] PROGMEM = {\n 0x21, 0x8E, 0x73, 0x18, 0xC6, 0x21, 0x19, 0xCE, 0x00, 0xEF"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansOblique12pt7b.h",
"chars": 19992,
"preview": "const uint8_t FreeSansOblique12pt7bBitmaps[] PROGMEM = {\n 0x0C, 0x61, 0x86, 0x18, 0x63, 0x0C, 0x30, 0xC2, 0x18, 0x61, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansOblique18pt7b.h",
"chars": 35958,
"preview": "const uint8_t FreeSansOblique18pt7bBitmaps[] PROGMEM = {\n 0x03, 0x83, 0x81, 0xC0, 0xE0, 0x70, 0x78, 0x38, 0x1C, 0x0E, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansOblique24pt7b.h",
"chars": 59762,
"preview": "const uint8_t FreeSansOblique24pt7bBitmaps[] PROGMEM = {\n 0x01, 0xE0, 0x3C, 0x0F, 0x81, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSansOblique9pt7b.h",
"chars": 13865,
"preview": "const uint8_t FreeSansOblique9pt7bBitmaps[] PROGMEM = {\n 0x10, 0x84, 0x22, 0x10, 0x84, 0x42, 0x10, 0x08, 0x00, 0xDE, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerif12pt7b.h",
"chars": 16738,
"preview": "const uint8_t FreeSerif12pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xFE, 0xA8, 0x3F, 0xCF, 0x3C, 0xF3, 0x8A, 0x20, 0x0C, 0x40, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerif18pt7b.h",
"chars": 29360,
"preview": "const uint8_t FreeSerif18pt7bBitmaps[] PROGMEM = {\n 0x6F, 0xFF, 0xFF, 0xFE, 0x66, 0x66, 0x66, 0x64, 0x40, 0x00, 0x6F, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerif24pt7b.h",
"chars": 48626,
"preview": "const uint8_t FreeSerif24pt7bBitmaps[] PROGMEM = {\n 0x77, 0xBF, 0xFF, 0xFF, 0xFF, 0xFB, 0x9C, 0xE7, 0x39, 0xCE, 0x61, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerif9pt7b.h",
"chars": 12051,
"preview": "const uint8_t FreeSerif9pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xEA, 0x03, 0xDE, 0xF7, 0x20, 0x11, 0x09, 0x04, 0x82, 0x4F, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifBold12pt7b.h",
"chars": 17694,
"preview": "const uint8_t FreeSerifBold12pt7bBitmaps[] PROGMEM = {\n 0x7F, 0xFF, 0x77, 0x66, 0x22, 0x00, 0x6F, 0xF7, 0xE3, 0xF1, 0xF"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifBold18pt7b.h",
"chars": 31768,
"preview": "const uint8_t FreeSerifBold18pt7bBitmaps[] PROGMEM = {\n 0x7B, 0xEF, 0xFF, 0xFF, 0xF7, 0x9E, 0x71, 0xC7, 0x0C, 0x20, 0x8"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifBold24pt7b.h",
"chars": 53806,
"preview": "const uint8_t FreeSerifBold24pt7bBitmaps[] PROGMEM = {\n 0x3C, 0x7E, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x7E, 0x7"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifBold9pt7b.h",
"chars": 12577,
"preview": "const uint8_t FreeSerifBold9pt7bBitmaps[] PROGMEM = {\n 0xFF, 0xF4, 0x92, 0x1F, 0xF0, 0xCF, 0x3C, 0xE3, 0x88, 0x13, 0x09"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifBoldItalic12pt7b.h",
"chars": 19248,
"preview": "const uint8_t FreeSerifBoldItalic12pt7bBitmaps[] PROGMEM = {\n 0x07, 0x07, 0x07, 0x0F, 0x0E, 0x0E, 0x0C, 0x0C, 0x08, 0x1"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifBoldItalic18pt7b.h",
"chars": 34664,
"preview": "const uint8_t FreeSerifBoldItalic18pt7bBitmaps[] PROGMEM = {\n 0x01, 0xC0, 0x7C, 0x0F, 0x81, 0xF0, 0x3E, 0x07, 0x80, 0xF"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifBoldItalic24pt7b.h",
"chars": 56292,
"preview": "const uint8_t FreeSerifBoldItalic24pt7bBitmaps[] PROGMEM = {\n 0x00, 0x3C, 0x00, 0xFC, 0x01, 0xF8, 0x07, 0xF0, 0x0F, 0xE"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifBoldItalic9pt7b.h",
"chars": 13521,
"preview": "const uint8_t FreeSerifBoldItalic9pt7bBitmaps[] PROGMEM = {\n 0x0C, 0x31, 0xC6, 0x18, 0x41, 0x08, 0x20, 0x0E, 0x38, 0xE0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifItalic12pt7b.h",
"chars": 17662,
"preview": "const uint8_t FreeSerifItalic12pt7bBitmaps[] PROGMEM = {\n 0x0C, 0x31, 0xC6, 0x18, 0x43, 0x0C, 0x20, 0x84, 0x10, 0x03, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifItalic18pt7b.h",
"chars": 30914,
"preview": "const uint8_t FreeSerifItalic18pt7bBitmaps[] PROGMEM = {\n 0x01, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0x81, 0xE0, 0x70, 0x1C, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifItalic24pt7b.h",
"chars": 52164,
"preview": "const uint8_t FreeSerifItalic24pt7bBitmaps[] PROGMEM = {\n 0x00, 0xF0, 0x0F, 0x00, 0xF0, 0x0F, 0x01, 0xF0, 0x1E, 0x01, 0"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/FreeSerifItalic9pt7b.h",
"chars": 12593,
"preview": "const uint8_t FreeSerifItalic9pt7bBitmaps[] PROGMEM = {\n 0x11, 0x12, 0x22, 0x24, 0x40, 0x0C, 0xDE, 0xE5, 0x40, 0x04, 0x"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/Org_01.h",
"chars": 7143,
"preview": "// Org_v01 by Orgdot (www.orgdot.com/aliasfonts). A tiny,\n// stylized font with all characters within a 6 pixel height."
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/Picopixel.h",
"chars": 6569,
"preview": "// Picopixel by Sebastian Weber. A tiny font\n// with all characters within a 6 pixel height.\n\nconst uint8_t PicopixelBi"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/Tiny3x3a2pt7b",
"chars": 6866,
"preview": "/**\n** The FontStruction “Tiny3x3a”\n** (https://fontstruct.com/fontstructions/show/670512) by “Michaelangel007” is\n** li"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/Fonts/TomThumb.h",
"chars": 24111,
"preview": "/**\n** The original 3x5 font is licensed under the 3-clause BSD license:\n**\n** Copyright 1999 Brian J. Swetland\n** Copyr"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/README.md",
"chars": 2998,
"preview": "# Adafruit GFX Library\n\nThis is the core graphics library for all our displays, providing a common set of graphics primi"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/fontconvert/Makefile",
"chars": 236,
"preview": "all: fontconvert\n\nCC = gcc\nCFLAGS = -Wall -I/usr/local/include/freetype2 -I/usr/include/freetype2 -I/usr/include\nLIB"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/fontconvert/fontconvert.c",
"chars": 9592,
"preview": "/*\nTrueType to Adafruit_GFX font converter. Derived from Peter Jakobs'\nAdafruit_ftGFX fork & makefont tool, and Paul Ko"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/fontconvert/fontconvert_win.md",
"chars": 3831,
"preview": "### A short guide to use fontconvert.c to create your own fonts using MinGW.\r\n\r\n#### STEP 1: INSTALL MinGW\r\n\r\nInstall Mi"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/fontconvert/makefonts.sh",
"chars": 1221,
"preview": "#!/bin/bash\n\n# Ugly little Bash script, generates a set of .h files for GFX using\n# GNU FreeFont sources. There are thr"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/gfxfont.h",
"chars": 924,
"preview": "// Font structures for newer Adafruit_GFX (1.1 and later).\n// Example fonts are included in 'Fonts' directory.\n// To use"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/glcdfont.c",
"chars": 8486,
"preview": "// This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0.\n// See gfxfont.h for newer custom bitmap fo"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/library.properties",
"chars": 388,
"preview": "name=Adafruit GFX Library\nversion=1.2.3\nauthor=Adafruit\nmaintainer=Adafruit <info@adafruit.com>\nsentence=Adafruit GFX gr"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Adafruit_GFX_Library/license.txt",
"chars": 1344,
"preview": "Software License Agreement (BSD License)\n\nCopyright (c) 2012 Adafruit Industries. All rights reserved.\n\nRedistribution "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/CAN/CAN.cpp",
"chars": 2556,
"preview": "#include \"CAN.h\"\n#include \"drv_can.h\"\n\nCANClass CanBus;\n\n#define OPENCR_CAN_CHANNEL 0 //CAN2\n\nCANClass::CANClass()\n{\n "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/CAN/CAN.h",
"chars": 1439,
"preview": "#ifndef _BSP_CAN_H_\n#define _BSP_CAN_H_\n\n#include <chip.h>\n#include \"variant.h\"\n#include \"drv_can.h\"\n#include \"def.h\"\n\n#"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/README.md",
"chars": 0,
"preview": ""
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/dynamixel_sdk.h",
"chars": 1370,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/group_bulk_read.h",
"chars": 7817,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/group_bulk_write.h",
"chars": 5717,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/group_sync_read.h",
"chars": 7939,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/group_sync_write.h",
"chars": 5418,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/packet_handler.h",
"chars": 35458,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler.h",
"chars": 8625,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler_arduino.h",
"chars": 8626,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler_linux.h",
"chars": 8356,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler_mac.h",
"chars": 8379,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/port_handler_windows.h",
"chars": 8365,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/protocol1_packet_handler.h",
"chars": 33213,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/include/dynamixel_sdk/protocol2_packet_handler.h",
"chars": 34594,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/keywords.txt",
"chars": 2097,
"preview": "#######################################\n# Syntax Coloring Map LatchClcd\n#######################################\n\n#######"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/library.properties",
"chars": 246,
"preview": "name=DynamixelSDK\nversion=0.0.1\nauthor=ROBOTIS\nmaintainer=RoBOTIS\nsentence=DynamixelSDK for OpenCR\nparagraph=https://git"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/DynamixelSDK.h",
"chars": 52,
"preview": "#include \"../include/dynamixel_sdk/dynamixel_sdk.h\"\n"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/group_bulk_read.cpp",
"chars": 6049,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/group_bulk_write.cpp",
"chars": 4327,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/group_sync_read.cpp",
"chars": 5392,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/group_sync_write.cpp",
"chars": 3556,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/packet_handler.cpp",
"chars": 1869,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/port_handler.cpp",
"chars": 1769,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/port_handler_arduino.cpp",
"chars": 6188,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/port_handler_linux.cpp",
"chars": 7850,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/port_handler_mac.cpp",
"chars": 6189,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/port_handler_windows.cpp",
"chars": 6643,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/protocol1_packet_handler.cpp",
"chars": 22559,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelSDK/src/dynamixel_sdk/protocol2_packet_handler.cpp",
"chars": 34787,
"preview": "/*******************************************************************************\n* Copyright 2017 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/include/dynamixel_workbench_toolbox/dynamixel_driver.h",
"chars": 6756,
"preview": "/*******************************************************************************\n* Copyright 2018 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/include/dynamixel_workbench_toolbox/dynamixel_item.h",
"chars": 3268,
"preview": "/*******************************************************************************\n* Copyright 2018 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/include/dynamixel_workbench_toolbox/dynamixel_tool.h",
"chars": 2369,
"preview": "/*******************************************************************************\n* Copyright 2018 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/include/dynamixel_workbench_toolbox/dynamixel_workbench.h",
"chars": 4729,
"preview": "/*******************************************************************************\n* Copyright 2018 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/keywords.txt",
"chars": 2089,
"preview": "#######################################\n# Syntax Coloring Map DynamixelWorkbench\n#######################################"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/library.properties",
"chars": 256,
"preview": "name=DynamixelWorkbench\nversion=0.1.0\nauthor=Darby Lim (thlim@robotis.com)\nmaintainer=Pyo(pyo@robotis.com)\nsentence=Dyna"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/src/DynamixelWorkbench.h",
"chars": 73,
"preview": "#include \"../include/dynamixel_workbench_toolbox/dynamixel_workbench.h\"\n\n"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/src/dynamixel_workbench_toolbox/dynamixel_driver.cpp",
"chars": 45917,
"preview": "/*******************************************************************************\n* Copyright 2018 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/src/dynamixel_workbench_toolbox/dynamixel_item.cpp",
"chars": 78376,
"preview": "/*******************************************************************************\n* Copyright 2018 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/src/dynamixel_workbench_toolbox/dynamixel_tool.cpp",
"chars": 8333,
"preview": "/*******************************************************************************\n* Copyright 2018 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/DynamixelWorkbench/src/dynamixel_workbench_toolbox/dynamixel_workbench.cpp",
"chars": 45370,
"preview": "/*******************************************************************************\n* Copyright 2018 ROBOTIS CO., LTD.\n*\n* "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/EEPROM/README.md",
"chars": 5143,
"preview": "## **EEPROM Library V2.0** for Arduino\n\n**Written by:** _Christopher Andrews_. \n\n### **What is the EEPROM library.**\n\nT"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/EEPROM/keywords.txt",
"chars": 502,
"preview": "#######################################\n# Syntax Coloring Map For EEPROM\n#######################################\n\n######"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/EEPROM/library.properties",
"chars": 466,
"preview": "name=EEPROM\nversion=2.0\nauthor=Arduino, Christopher Andrews\nmaintainer=Arduino <info@arduino.cc>\nsentence=Enables readin"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/EEPROM/src/EEPROM.h",
"chars": 5383,
"preview": "/*\n EEPROM.h - EEPROM library\n Original Copyright (c) 2006 David A. Mellis. All right reserved.\n New version by Chri"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/library.properties",
"chars": 185,
"preview": "name=Eigen\nversion=3.3.1\nauthor=\nmaintainer=\nsentence=Eigen for OpenCR\nparagraph=\ncategory=Data Processing\nurl=http://ei"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/CMakeLists.txt",
"chars": 694,
"preview": "include(RegexUtils)\ntest_escape_string_as_regex()\n\nfile(GLOB Eigen_directory_files \"*\")\n\nescape_string_as_regex(ESCAPED_"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Cholesky",
"chars": 1129,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/CholmodSupport",
"chars": 1900,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Core",
"chars": 17339,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Dense",
"chars": 122,
"preview": "#include \"Core\"\n#include \"LU\"\n#include \"Cholesky\"\n#include \"QR\"\n#include \"SVD\"\n#include \"Geometry\"\n#include \"Eigenvalues"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Eigen",
"chars": 35,
"preview": "#include \"Dense\"\n#include \"Sparse\"\n"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Eigenvalues",
"chars": 1763,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Geometry",
"chars": 2050,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Householder",
"chars": 874,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/IterativeLinearSolvers",
"chars": 2083,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Jacobi",
"chars": 939,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/LU",
"chars": 1374,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/MetisSupport",
"chars": 991,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/OrderingMethods",
"chars": 2483,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/PaStiXSupport",
"chars": 1676,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/PardisoSupport",
"chars": 1116,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/QR",
"chars": 1258,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/QtAlignedMalloc",
"chars": 930,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/SPQRSupport",
"chars": 1162,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/SVD",
"chars": 1570,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/Sparse",
"chars": 888,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/SparseCholesky",
"chars": 1371,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2013 G"
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/SparseCore",
"chars": 2240,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "arduino/opencr_arduino/opencr/libraries/Eigen331/src/Eigen/SparseLU",
"chars": 1711,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
}
]
// ... and 1421 more files (download for full content)
About this extraction
This page contains the full source code of the ROBOTIS-GIT/OpenCR GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1621 files (25.6 MB), approximately 6.8M tokens, and a symbol index with 10056 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.