Question

我有来自传感器的加速度数据。 X Y＆amp; Z.我在Y轴上移动传感器。大多数是直线。所以我忽略x＆amp; ž。

从传感器文档5.2.1加速输出：

ax =（（AxH <＆lt; 8）| AxL）/ 32768 * 16g（g为重力加速度，9.8m / s2）

ay =（（AyH <8）| AyL）/ 32768 * 16g（g为重力加速度，9.8m / s2）

az =（（AzH <＆lt; 8）| AzL）/ 32768 * 16g（g为重力加速度，9.8m / s2）

数据在（m / s2）

我需要一个简单的计算，java或C＃可以轻松完成。我想在代码中写一些东西来计算随时间的加速度到最大速度和平均速度。我需要一个＆＃34;速度＆＃34;我可以显示的价值。对于Ex。最高速度12MPH，平均速度8MPH。

- 编辑更好的数据将其移动12英寸 - 这是工作代码

@Autowired
private MessageChannel requestsChannel;

@Autowired
private PollableChannel aggregatedReplyChannel;

@Bean
public JobExecutionListener listener() {
    return new RadJobExecutionListener();
}

@Bean
public Job RadItemProcessingJob() {
    return jobBuilderFactory.get("radItemProcessingJob")
            .incrementer(new RunIdIncrementer())
            .listener(listener())
            .start(processRadItems_master()).next(updateSetStatusStep())
            .build();
}

@Bean
public Tasklet noopTaskLet() {
    return new NoopTasklet();
}

@Bean
public Tasklet updateSetStatusStepTasklet() {
    return new UpdateSetStatus();
}

@Bean
public Step processRadItems() {
    return stepBuilderFactory.get("processRadItems")
            .tasklet(noopTaskLet())
            .build();
}

@Bean
public Partitioner moduloPartitioner() {
    return new ModuloPartitioner();
}

@Bean
public PartitionHandler partitionHandler() {
    return createPartitionHandler("processRadItems",
            gridSize,
            requestsChannel,
            aggregatedReplyChannel
    );
}


public PartitionHandler createPartitionHandler(String stepName,
                                               int gridSize,
                                               MessageChannel requestChannel,
                                               PollableChannel replyChannel) {
    MessageChannelPartitionHandler partitionHandler = new MessageChannelPartitionHandler();
    partitionHandler.setStepName(stepName);
    partitionHandler.setGridSize(gridSize);
    partitionHandler.setReplyChannel(replyChannel);
    MessagingTemplate messagingTemplate = new MessagingTemplate(requestChannel);
    partitionHandler.setMessagingOperations(messagingTemplate);
    return partitionHandler;
}

@Bean Step processRadItems_master() {
    return stepBuilderFactory.get("processRadItems.master")
            .partitioner("processRadItem",moduloPartitioner())
            .partitionHandler(partitionHandler())
            .build();
}


@Bean Step updateSetStatusStep() {
    return stepBuilderFactory.get("updateSetStatusStep")
            .tasklet(updateSetStatusStepTasklet())
            .build();
}

@Bean
JobLauncher jobLauncher() {
    TaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
    SimpleJobLauncher simpleJobLauncher = new SimpleJobLauncher();
    simpleJobLauncher.setTaskExecutor(taskExecutor);
    simpleJobLauncher.setJobRepository(jobRepository);
    return simpleJobLauncher;

}

Answer 1

速度是加速度的整合。如果初始速度为0，那么您可以用Riemann integral（*）来评估速度;加速度函数的区域。

对于一般功能fx，你可以这样做：

public static double RiemannIntegration
    (Func<double, double> fx,
     double x0,
     double x1,
     double step)
{
    var previous = x0;
    var res = 0d;
    var semiStep = step / 2;

    for (var x = x0 + step; x < x1; x += step)
    {
        res += semiStep * (fx(x) + fx(previous));
        previous = x;
    }

    res += (x1 - previous) / 2 * (fx(x1) + fx(previous));
    return res;
}

但也许更具体的实现对您的场景更有用;给定一系列(t, acc)数据，用每个t定义的变量步长来评估黎曼积分。此实现考虑了每个区间内加速度的线性变化：

public static double RiemannIntegration(
    (double X, double Y)[] xy)
{
    var res = 0d;

    for (var i = 1; i < xy.Length; i++)
    {
        res += (xy[i].X - xy[i - 1].X) * (xy[i].Y + xy[i - 1].Y) / 2;
    }

    return res;
}

更新：根据您的评论，您最终想要评估所涵盖的距离。您可以通过将加速度积分两倍来实现此目的，但为了做到这一点，您实际上需要返回积分曲线，而不是总值。以下实现将执行此操作：

public static IEnumerable<(double X, double Y)> RiemannIntegration(
    (double X, double Y)[] xy, double initialValue)
{
    var res = initialValue;
    yield return (xy[0].X, initialValue);

    for (var i = 1; i < xy.Length; i++)
    {
        res += (xy[i].X - xy[i - 1].X) * (xy[i].Y + xy[i - 1].Y) / 2;
        yield return (xy[i].X, res);
    }
}

现在要评估你要做的距离形式加速度数据：

var timeVsAccelerationData = new[] { (t0, a0), (t1, a1), ... };

//initial speed and distance are zero.
var distance = RiemmanIntegral(RiemannIntegral(
    timeVsAccelerationData, 0).ToArray(), 0).Last().Y;

（*）所提出的算法并不完全是黎曼积分，我使用的是梯形区域，Riemann积分实际上使用的矩形区域的高度等于时间间隔中心的函数值。

将加速度随时间转换为代码中的速度或速度

1 个答案: