@dlee ,

Yes the new TOF sensor (IRS2975C) is more powerful that the previous generation. What I mean by that is that it can emit more IR power but also heats up more. Emitting more power allows the sensor detect objects at larger distances or objects that are not as reflective.

In current operating mode, the auto exposure control is enabled inside the sensor itself, which modulates the emitted IR power based on the returns that the sensor is getting. That is to say, the power draw will vary depending on what is in the view of the sensor. If there are obstacles nearby, the output power should be low, otherwise it can be high. At full power, the module can consume close to 0.8-0.9W

So the first solution, if design allows, is to add a heat spreader to dissipate the heat, which you already started experimenting with. The sensor has a large exposed copper pad in the back for heat sinking purposes for this exact reason. Just be careful not to short this pad to anything, use non-conducting (but heat transfering) adhesive pad between the sensor and heat spreader.

In terms of a software solution to the issue, we can query the temperature of the emitter. We can also control the maximum emitted power used by the auto exposure algorithm. That is to say, still leave the auto exposure running in the sensor, but limit the maximum power that it is allowed to use.

We are planning to add some software protection that limits the maximum output power as a function of the emitter temperature. This will require some implementation and testing.

Meanwhile, please consider using a heat spreader, which will be the best solution if you want to make use of the full sensor's operating range and not have our software limit the output power in order to prevent overheating.

Hello @Kashish-Garg-0

we have a curve that is "motor voltage vs rpm", meaning that for a desired RPM, it tells the ESC what average motor voltage should be applied. The average motor voltage is defined as battery_voltage * motor_pmw_duty_cycle. The battery voltage in this curve is in millivolts. Since you are typically controlling the desired RPM, as a user you do not need to worry about what "throttle" or voltage to apply - the ESC does this automatically in order to achieve the desired RPM. this calibration curve is used as a feed-forward term in the RPM controller. The ESC does support an "open loop" type of control where you specify the power from 0 to 100%, which is similar to a standard ESC, but PX4 does not use that ESC control mode.

By the way, you can test the ESC directly (not using PX4) using our voxl-esc tools (https://gitlab.com/voxl-public/voxl-sdk/utilities/voxl-esc/-/tree/master/voxl-esc-tools) which works directly on VOXL2 or a standalone linux PC (or mac). voxl-esc-spin.py has a --power argument where you specify the power from 0 to 100, which translates directly to the average duty cycle applied to the motor.

Here is the calibration for the Starling V2 motor / propeller that we use:
https://gitlab.com/voxl-public/voxl-sdk/utilities/voxl-esc/-/blob/master/voxl-esc-params/mavic_mini_2/mavic_mini_2.xml?ref_type=heads#L63

Also, you can take a look at this post to see how to interpret those parameters a0, a1, a2 : https://forum.modalai.com/topic/2522/esc-calibration/2

We also have some dyno tests for this motor / propeller : https://gitlab.com/voxl-public/flight-core-px4/dyno_data/-/blob/master/data/mavic_mini2_timing_test/mavic_mini2_modal_esc_pusher_7.4V_timing0.csv . We are not sure how accurate that is, but it can be used as a starting point. @James-Strawson can you please confirm that is the correct dyno data for the Starling V2 motors?

Alex

@reber34 , perhaps this approach can work for you:

• record a video encoded at high bit rate (using voxl-camera-server and voxl-record-video . Please note that the output of voxl-record-video will not be in a standard container (such as mp4, etc), but you can fix it with ffpeg : ffmpeg -r 30 -i voxl-record-video.h264 -codec copy videofile.mp4
• re-encode the video offline with desired codecs / bit rates / resolutions
• install gst-rtsp-launch which uses gstreamer to set up an RTSP stream https://github.com/sfalexrog/gst-rtsp-launch/
  • you will first need to figure out what gstreamer pipeline to use on voxl2 that will load your video and parse the h264/h265 frames (can use null sink for testing) and then use that pipeline with gst-rtsp-launch which will take the encoded frames and serve them over rtsp stream.
• gstreamer may be more flexible for tuning the encoding parameters of h264/h265 (compared to voxl-camera-server) and you can also use it in real time later (using voxl-streamer, which uses gstreamer under the hood)

Another alternative is to use voxl-record-raw-image to save raw YUVs coming from voxl-camera-server and then use voxl-replay and voxl-streamer - the latter will accept YUVs from the MPA pipe and encode them using the bit rate that you want. Note that depending on the image resolution, YUV images will take a lot more space than encoded video, but maybe that is also OK since VOXL2 has lots of storage.

Alex

@jimbow77 and @oasisartisan ,

TOF V1 (which is now EOL, so you don't have it on Starling 2 Max) was set up the following way:

• The calibration data was downloaded the first time the sensor was used and stored in /data/misc/camera/, then re-used for next time
• calibration files include pmd.spc, tof_cal_eeprom.bin and irs10x0c_lens.cal - the latter likely containing the intrinsics calibraiton data (although i have not checked explicitly)

TOF V2 (what is shipping in Starling 2 (and Max) ), is set up so that the TOF Library downloads (via i2c) the calibration data each time the voxl-camera-server starts. This is done internally to the TOF libraries. I don't know exactly why there is a difference between how the calib data is handled for two sensors by the TOF software, but this is how our sensor vendor helped us set it up. The TOF processing software downloads the calibration from the sensor each time voxl-camera-server starts and applies it to generate the point cloud. It may be possible to get the TOF intrinsics using the TOF library API, but we have not checked.

Do you have a specific reason why the TOF intrinsics are needed?

If you wanted to calibrate the TOF sensor yourself, then you would either need a checkerboard some material that is IR reflective ("white") and non-reflective ("black"). Alternatively, you could use an array of IR leds (or IR reflective dots + IR light) and use dot pattern detector as opposed for checkerboard for calibration.

Regarding Hi-res cameras, the intrinsics are not calibrated and not included. It can be calibrated using our camera calibration app (voxl-camera-calibration), but you should do it at half resolution or smaller (not full size like 4056x3040), otherwise the app runs very slowly. If you need more details how to calibrate at high resolution, let me know (involves downscaling exactly by a factor of 2 and then upscaling the resulting intrinsics)

Alex

@smilon , voxl-esc-calibrate.py is a script that runs a test procedure in a single motor (with propeller mounted) to calibrate the behavior of the motor / propeller. This procedure only needs to be run once if you change motor or propeller type from a default configuration. The output of this script is just 3 coeficients a1, a2, a3 which you would need to manually enter into an ESC calibration xml file and then upload the xml paramer file to the ESC. Full details about the ESC calibration (when to do it and how) can be found here : https://gitlab.com/voxl-public/voxl-sdk/utilities/voxl-esc/-/blob/master/voxl-esc-tools/calibration.md?ref_type=heads

If you are using standard motors and propellers (one of standard ModalAI drones), you do not need to run this calibration procedure.

It sounds like you got it working, I believe voxl-configre-mpa took care of it. You can see what voxl-configure-mpa typically does here : https://docs.modalai.com/voxl-configure-mpa/ , which includes running voxl-esc to upload the latest firmware and params for a specific vehicle.

Hello @Gicu-Panaghiu,

I am going to assume you are using VOXL1, since you did not specify..

We do have RAW8 and RAW10 support for OV7251. The selection of the format has to be done in several places.

First, you have to select the correct camera driver, specifically..

ls /usr/lib/libmmcamera_ov7251*.so
/usr/lib/libmmcamera_ov7251.so
/usr/lib/libmmcamera_ov7251_8bit.so
/usr/lib/libmmcamera_ov7251_hflip_8bit.so
/usr/lib/libmmcamera_ov7251_rot180_8bit.so
/usr/lib/libmmcamera_ov7251_vflip_8bit.so

there are 5 options and one of them is _8bit.so which means it will natively ouptput 8bit data (all others output 10 bit data).

the driver name, such as ov7251_8bit has to be the sensor name <SensorName>ov7251_8bit</SensorName> in /system/etc/camera/camera_config.xml.

You can check camera_config.xml for what sensor library is used for your OV7251.

When you run voxl-configure-cameras script, it will actually copy one of the default camera_config.xml that are set up for a particular use case, and I believe it will indeed select the 8bit one - this was done to save cpu cycles needed to convert 10bit to 8bit, since majority of the time only 8bit pixels are used.

Now, you mentioned that HAL_PIXEL_FORMAT_RAW10 is passed to the stream config and unfortunately this does not have any effect on what the driver outputs. If the low level driver (e.g. libmmcamera_ov7251_8bit.so) is set up to output RAW8, it will output RAW8 if you request either HAL_PIXEL_FORMAT_RAW8 or HAL_PIXEL_FORMAT_RAW10.

So if you update the camera_config.xml to the 10bit driver and just keep the HAL_PIXEL_FORMAT_RAW10 in the stream config (then sync and reboot), you should be getting a 10 bit RAW image from the camera. But since the camera server is currently expecting 8 bit image, if you just interpret the image as 8 bit, it will appear garbled, so you will need to handle the 10 bit image (decide what you want to do with it) in the camera server.

@jakkkkobo ,

The source code of voxl-send-neopixel-cmd test tool is here : https://gitlab.com/voxl-public/voxl-sdk/services/voxl-io-server/-/blob/master/tools/voxl-send-neopixel-cmd.c

The function that creates a binary packet (which is forwarded to the ESC via PX4) is here : https://gitlab.com/voxl-public/voxl-sdk/services/voxl-io-server/-/blob/master/lib/modal_io.c#L181 . Basically you need to provide the following information to this function:

• number of LEDs you are controlling
• LED type (RGB or RGBW)
• array of LED colors (3 bytes for each LED in case of RGB, or 4 bytes per LED for RGBW).
• the array should contain all LED values ranging from 0-255, so if you had 3 LEDs and first should be red, second green and third blue (50% power), the LED color array would be : [127, 0, 0, 0, 127, 0, 0,0,127].
• this function will create a packet with checksum and send it to PX4, and PX4 will forward the packet to the ESC.

You can modify the voxl-send-neopixel-cmd to do what you need, maybe you can make it accept an array of LED color values via command line.

I know the tool could have been more helpful. If you describe your use case, maybe I can help improve the voxl-send-neopixel-cmd tool.

Alex

@KnightHawk06 , use voxl-calibrare-camera tracking_down_misp_grey <remaining options>

The ipk is available here now : http://voxl-packages.modalai.com/stable/voxl-hal3-tof-cam-ros_0.0.5.ipk - you should be able to use the launch file to choose between two modes (5=short range and 9=long range) and fps, which are listed in the launch file.

@Moderator said in VOXL ESC Mini 4-in-1 Current per Motor:

Is it possible to step up voltage?

Can you please clarify the question?

Mini ESC is designed for small drones ( < 500g ). The ESC has been tested to handle 15A continous at 15V input continuously (60+ seconds), but with full direct air flow from propellers. This would simulate a full throttle "punch-out" on a small FPV drone (high current, but also lots of direct airflow = cooling). Do not use this ESC if the drone needs 10-15A per channel just to hover. Use it in application where hover current per motor is less than 5A (ideally 2-3A which is very typical) and absolute maximum continuous current per motor can be 10-15A.

For example, motors used for small FPV drones often are around 1306 size (3-4S Lipo). Those motors are usually rated for up to 10-12A continous (for 30-60 seconds). Larger motors can be used as long as maximum motor current does not exceed 10-15A (still 2-3A at hover) and there is sufficient cooling.

Always check ESC board temperature during initial flights / tuning. Temperature must stay below 110C at all times (critical), typically in the range of 40-70C for most applications. The ESC will most likely fail above 125C.

Temperature of the ESC board is the limiting factor because the board is so small. Mosfets can handle a lot of current as long as they don't overheat. So the design of the drone is very important (either use low current so that temperature is not an issue or properly design air flow from propellers and/or add heat spreader to keep the ESC board temperature in normal range for higher current draw applications).

ESC provides real time temperature feedback and it can be viewed in PX4 / QGC. Additionally, the PX4 logs contain the temperature information.

@Eyal , sorry for the delay. Here is some additional information regarding Stinger FPV:

• https://docs.modalai.com/stinger-vision-datasheet/
• base weight with battery : ~570g
• maximum thrust per motor : 650g @ 15V, 2600g total theoretical
• theoretical max thrust to weight ratio: 4.5:1, lots of extra margin, but if you add a LOT of weight, will need to check motor temps, etc.
• CAD model for stinger (may be slightly outdated) : https://forum.modalai.com/topic/5180/looking-stinger-fpv-cad-models -- you can attach your payload to carbon fiber
• I think that Stinger will be easier to tune up with additional payload because of more responsive and powerful propulsion system than Starling 2.
• i dont know what your sensor package is so, it is hard to comment about which platform is better. Starling 2 has landing gear that offsets it from the floor. Stringer is much lower to the ground.

Alex

@awagner

You have the wrong kernel variant installed (2.0.2 instead of 2.0.0) on your voxl2 mini. You should re-install the SDK and select the correct kernel.

On the VOXL2 Mini, kernel versions 2.0.0 and 2.0.2 are ModalAI hardware/kernel variant identifiers (mach.var) used to select the correct device-tree and hardware configuration for different carrier/camera setups.

The key practical difference is:

Variant | Intended Hardware Configuration
2.0.0 | Standard VOXL2 Mini configuration / legacy non-coax adapters (what you are using)
2.0.2 | VOXL2 Mini configured for the M0188, M0194, M0195 and other u-coax camera adapters

When flashing the SDK, the installer exposes this as:

• Standard VOXL2 Mini (2.0.0)
• VOXL2 Mini with M0188 Camera Breakout Board (2.0.2)

Alex

Hi @qubotics-admin , a few comments:

• you don't need to re-calibrate per motor -- one time calibration for the motor / propeller time is sufficient
• make sure to update the correct kV value in the spinup params. although it probably is not the issue here since your motor is 2300kV and the params you started with are for 2400kv, but it's good to make it right. This param affect the spinup procedure.

Questions:

• the the motor connected to ID2 spin at all during the initial spin-up procedure? are you able to share a video?
• if you extend the spinup from 0.5s to 1.0 second, does the same issue persist?
• if you increase the spinup power a bit (i think it may be set to 100 right now (10%), make it 120 and test again? If the current spinup power is not 100 -- whatever it is now, increase by 20% for a test and see if that helps (change it back after the test if there is no improvement).
  • note that if the motor does spin up, it is important to note the rpm at a specific commanded power and compare that rpm to other motors. Sometimes it is possible for a motor to spin even with a partially shorted windings or an issue in the ESC, but it would spin slower than normal, especially under load (with propeller attached).
• i know you said that swapping the motor did not help, but it would be good to test the motor that is not spinning now on ID2 by switching this motor to another ESC ID and making sure it spins ok.

Also,

• please make sure that the windings of the motor are not damaged by the motor mounting screws. this is a common issue when the motor mounting screws are too long and they penetrate into the windings, creating a partial short
• if you have a milliohm meter, the winding resistance can be verified (it should be the same for any pairwise test of any phases for all motors of the same type -- within a few percent)
• inspect the ESC for any debris or any other objects touching the ESC board

Alex

Hi @qubotics-admin ,

Between the two tests, i see that one test shows 16V input voltage and the other test ~7.2V. Was the voltage applied to the ESC the same during the tests (and the ESC read it incorrectly) or the voltage was in fact different?

Such a big difference can have adverse affects on spin-up if the change in voltage is not accounted for in the esc tuning param file.

It is possible that if the ESC does not have correct parameters for your motor / propeller, the sinusoidal spinup does not have enough power and loses tracking during the spin-up phase and fails to transition to steady-state spin stage.

The ESC channel 2 on the FPV ESC is the only channel that measures the total board current, so that is why the printout is slightly different when you test the channel 2.

Please provide the following details that will help us figure out the issue:

• what voltage are you testing the ESC? 16V or 7V?
• what motor/propeller do you have and which ESC params are you using?
• does the "bad" ESC channel ever properly spin up, or it never spins up at any battery voltage?
• is this the first time you are using this motor + propeller + voltage combination with the FPV ESC , or it has been previously working reliably?
• have you performed any ESC parameter tuning using voxl-esc tools?

Alex

@jameskuesel , i have been testing a version of camera server that supports independent zoom / drag on each of the 4 misp channels and also independent EIS modes. This means that you can have one full size unstabilized image and one or more stabilized with EIS and arbitrary zoom and look-at positions for each stream.

There is also an updated voxl-portal version that has the multi view that supports showing and interactive with multiple streams at the same time.

If you would like to test it, let me know, i will need to document a bit. Please provide some more information such as what camera you use and what use cases you need, so i can provide an exact camera server config to test (basically specs for each misp channel, - fps, dims, eis/on off and eis mode)

Alex

Hello @Mason-N ,

Going back in git history, I was able to find the seeker documentation. I think this is what you are looking for:

https://gitlab.com/voxl-public/support/documentation/-/tree/530dadd6fb9d50654ea34496c3d7f02d142fd732/docs/20-dev-drones/45-seeker

https://gitlab.com/voxl-public/support/documentation/-/tree/530dadd6fb9d50654ea34496c3d7f02d142fd732/docs/20-dev-drones/45-seeker/10-seeker-user-guide

Hi @Eyal ,

• The full weight of a standard Starling 2 is about 285g (with battery).

• the maximum motor thrust at full power is ~185g (at 7.5V) -- single motor

• this means the total max thrust for 4 motors is about 740g , which means about 2.6 thrust to weight ratio

  • please keep in mind that you can never apply full power to all 4 motors due to needed motor rpm differential for control

• it is a good practice to have at least 2.0 thrust to weight ratio in order to maintain good flight control. If you follow that guidance, it means that you can add about 85 extra grams to Starling 2 and it would be at 370g

  • flight time (hover) will drop from ~35 mins to ~25 mins (not exactly linear due to lower motor/prop efficiency at higher thrust)

• it is always recommended to try to keep the center of mass as close as possible to the geometrical center of the vehicle in order to reduce the moment of intertia and off-center mass which can affect control.

• depending on where the bulk of the weight is added, re-tuning flight (attitude) controller may be needed. extra weight far from vehicle center will increase moment of intertia, so the controller will need to adjust

Stinger FPV drone is a very different vehicle and although it is smaller than Starling 2 Max, the flight time of Stinger is significantly shorter due to.. smaller propellers, heavier (more durable) frame, etc

I think it all depends on what sensors you are planning today. If you want to share that, we can try to help..

Alex

@RoyAzriel ,

you can back up your voxl-camera-server.conf and then run voxl-configure-cameras 29 and the following will happen:

• all the existing sensormodule files will be wiped from /usr/lib/camera to avoid confusion
• only those sensormodules that belong in C29 config will be copied from /usr/share/modalai/chi-cdk to /usr/lib/camera
• the camera server config file (/etc/modalai/voxl-camera-server.conf) will be overwritten with the defaults for C29 configuration -- you can then see the config entry for TOF sensor and copy/paste that into your old config file, if you wish or use the new config file as is.

Alex

The old seeker documentation can be found in the docs source here : https://gitlab.com/voxl-public/support/documentation/-/blob/master/docs/999-Hidden/51-seeker.md (gitlab should render the markdown). Please let me know if there is anything else that you cant find.

Alex

Hi @Mason-N ,

OK, let me check again. Can you measure the diameter of the propellers that you have (it should be two types, it looks like) and let me know?

Alex