NXP JN516X (TWELITE) をプログラミングする（ALARM)

前回投稿のTimerでも5個使えるので必要ないかもしれないが、RP2040用に作成したアラームライブラリを移殖してみた。

１つのTimerを使って制限なく複数のマイクロ秒(64bit)指定の割り込み処理が可能で誤差のないリピート割り込みだったりインターバルを変更できたりする特徴をもつ超便利なライブラリだ。若干管理コストがかかるというデメリットはあるが簡単に使えるのでタイマー割り込みならこのライブラリ一択でＯＫだと思う。

【アラーム割り込みで一秒毎にＬチカするサンプル・コード】

#include "device.h"

#define LED Gpio::DIO18

Alarm alarm;

bool AlarmCallback(Alarm& alarm)
{
  Gpio::digitalWrite(LED, !Gpio::digitalRead(LED));
  return true; // true: Continue, false: Stop.
}

void setup(void)
{
  Gpio::pinMode(LED, Gpio::OUTPUT);
  AlarmTimer.start(alarm.interval(1000000).handler(AlarmCallback));
}

void loop(void)
{
}

#include "device.h"

#define LED Gpio::DIO18

Alarm alarm;

bool AlarmCallback(Alarm& alarm)

{

Gpio::digitalWrite(LED, !Gpio::digitalRead(LED));

return true; // true: Continue, false: Stop.

}

void setup(void)

{

Gpio::pinMode(LED, Gpio::OUTPUT);

AlarmTimer.start(alarm.interval(1000000).handler(AlarmCallback));

}

void loop(void)

{

}

【アラーム・ポーリングで一秒毎にＬチカするサンプル・コード】

#include "device.h"

#define LED Gpio::DIO18

Alarm alarm;

void setup(void)
{
  Gpio::pinMode(LED, Gpio::OUTPUT);
  alarm.interval(1000000);
}

void loop(void)
{
  if (alarm.expire())
    Gpio::digitalWrite(LED, !Gpio::digitalRead(LED));
}

#include "device.h"

#define LED Gpio::DIO18

Alarm alarm;

void setup(void)

{

Gpio::pinMode(LED, Gpio::OUTPUT);

alarm.interval(1000000);

}

void loop(void)

{

if (alarm.expire())

Gpio::digitalWrite(LED, !Gpio::digitalRead(LED));

}

【修正履歴】
2022-05-01
ポーリングでも使えるようにAlarmクラスにbool expire(void)を追加。Alarmクラス単体で気軽に使えるので便利かも。

/*
  alarm.h - Alarm Library for XNP-JN516x

  Copyright (c) 2022 Sasapea's Lab. 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., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/
#pragma once

#include <jendefs.h>
#include <AppHardwareApi.h>
#include "timer.h"

class Alarm
{
  public:

    typedef bool (*handler_t)(Alarm& alarm);

    Alarm& interval(int64 interval, bool fromnow = true);
    int64 interval(void);
    Alarm& handler(handler_t handler);
    handler_t handler(void);
    Alarm& param(uint8 num, void *val);
    void *param(uint8 num);
    bool expire(void);

  protected:

    friend class AlarmClass;

    Alarm    *_next;
    uint64    _alarm;
    int64     _interval;
    handler_t _handler;
    void     *_params[4];
};

class AlarmClass
{
  public:

    void begin(void);
    void begin(Timer::TIMER timer);
    bool start(Alarm& alarm);
    void cancel(Alarm& alarm);
    void cancel(uint8 num, void *arg);

  protected:

    bool add(Alarm& alarm);
    void restart(int64 interval);

  private:

    void timeup(void);

    static void TimerCallback(uint32 u32Device, uint32 u32ItemBitmap);

    Timer::TIMER _timer;
    Alarm *_alarm_list;
};

extern AlarmClass AlarmTimer;

alarm.h - Alarm Library for XNP-JN516x

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., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

#pragma once

#include <jendefs.h>

#include <AppHardwareApi.h>

#include "timer.h"

class Alarm

{

public:

typedef bool (*handler_t)(Alarm& alarm);

Alarm& interval(int64 interval, bool fromnow = true);

int64 interval(void);

Alarm& handler(handler_t handler);

handler_t handler(void);

Alarm& param(uint8 num, void *val);

void *param(uint8 num);

bool expire(void);

protected:

friend class AlarmClass;

Alarm *_next;

uint64 _alarm;

int64 _interval;

handler_t _handler;

void *_params[4];

};

class AlarmClass

{

public:

void begin(void);

void begin(Timer::TIMER timer);

bool start(Alarm& alarm);

void cancel(Alarm& alarm);

void cancel(uint8 num, void *arg);

protected:

bool add(Alarm& alarm);

void restart(int64 interval);

private:

void timeup(void);

static void TimerCallback(uint32 u32Device, uint32 u32ItemBitmap);

Timer::TIMER _timer;

Alarm *_alarm_list;

};

extern AlarmClass AlarmTimer;

/*
  alarm.cpp - Alarm Library for NXP-JN516x

  Copyright (c) 2022 Sasapea's Lab. 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., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/
#include "alarm.h"
#include "system.h"

#define lengthof(a) (sizeof(a)/sizeof(a[0]))

AlarmClass AlarmTimer;

static AlarmClass *_instances[5];

void AlarmClass::begin(void)
{
  _timer = (Timer::TIMER)-1;
#ifdef ALARM_TIMER
  begin((Timer::TIMER)ALARM_TIMER);
#endif
}

void AlarmClass::begin(Timer::TIMER timer)
{
  if (timer < lengthof(_instances))
  {
    _timer      = timer;
    _alarm_list = NULL;
    _instances[_timer] = this;
    Timer::begin(timer, Timer::CLOCK_1MHZ, false, true, false, TimerCallback);
  }
}

bool AlarmClass::start(Alarm& alarm)
{
  if (((int8)_timer < 0) || (alarm._interval < 1) || !alarm._handler)
    return false;
  uint32 save = System::disableAndSaveInterrupts();
  if (add(alarm))
    restart(_alarm_list->_alarm - System::micros64());
  System::restoreInterrupts(save);
  return true;
}

void AlarmClass::cancel(Alarm& alarm)
{
  uint32 save = System::disableAndSaveInterrupts();
  for (Alarm **p = &_alarm_list; *p; p = &(*p)->_next)
  {
    if (*p == &alarm)
    {
      *p = (*p)->_next;
      break;
    }
  }
  System::restoreInterrupts(save);
}

void AlarmClass::cancel(uint8 num, void *arg)
{
  if ((num < lengthof(Alarm::_params)) && arg)
  {
    uint32 save = System::disableAndSaveInterrupts();
    for (Alarm **p = &_alarm_list; *p; p = &(*p)->_next)
    {
      if ((*p)->_params[num] == arg)
      {
        *p = (*p)->_next;
        break;
      }
    }
    System::restoreInterrupts(save);
  }
}

bool AlarmClass::add(Alarm& alarm)
{
  Alarm **p;
  for (p = &_alarm_list; *p && ((int64)((*p)->_alarm - alarm._alarm) <= 0); p = &(*p)->_next)
    continue;
  alarm._next = *p;
  *p = &alarm;
  return p == &_alarm_list;
}

void AlarmClass::TimerCallback(uint32 u32Device, uint32 u32ItemBitmap)
{
  (void)u32Device;     // E_AHI_DEVICE_TIMERx
  (void)u32ItemBitmap; // E_AHI_TIMER_PERIOD_MASK or E_AHI_TIMER_RISE_MASK
  _instances[Timer::id(u32Device)]->timeup();
}

void AlarmClass::timeup(void)
{
  Alarm *p = NULL;
  while (_alarm_list)
  {
    int64 t = _alarm_list->_alarm - System::micros64();
    if (p || (t > 0))
    {
      restart(t);
      return;
    }
    _alarm_list = (p = _alarm_list)->_next;
    if (p->_handler(*p))
    {
      p->_alarm += p->_interval;
      if (!add(*p))
        p = NULL;
    }
    else
      p = NULL;
  }
}

void AlarmClass::restart(int64 interval)
{
  uint16 n;
  if (interval <= 1)
    n = 2;
  else if (interval & ~0xFFFF)
    n = (uint16)-1000; // leave 1ms or more.
  else
    n = (uint16)interval;
  Timer::startSingleShot(_timer, 0, n);
}

Alarm& Alarm::interval(int64 interval, bool fromnow)
{
  if (fromnow)
    _alarm = System::micros64() + interval;
  _interval = interval;
  return *this;
}

int64 Alarm::interval(void)
{
  return _interval;
}

Alarm& Alarm::handler(Alarm::handler_t handler)
{
  _handler = handler;
  return *this;
}

Alarm::handler_t Alarm::handler(void)
{
  return _handler;
}

Alarm& Alarm::param(uint8 num, void *val)
{
  if (num < lengthof(_params))
    _params[num] = val;
  return *this;
}

void *Alarm::param(uint8 num)
{
  return num < lengthof(_params) ? _params[num] : NULL;
}

bool Alarm::expire(void)
{
  if ((int64)(System::micros64() - _alarm) < 0)
    return false;
  do
    _alarm += _interval;
  while ((int64)(System::micros64() - _alarm) >= 0);
  return true;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

alarm.cpp - Alarm Library for NXP-JN516x

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., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

#include "alarm.h"

#include "system.h"

#define lengthof(a) (sizeof(a)/sizeof(a[0]))

AlarmClass AlarmTimer;

static AlarmClass *_instances[5];

void AlarmClass::begin(void)

{

_timer = (Timer::TIMER)-1;

#ifdef ALARM_TIMER

begin((Timer::TIMER)ALARM_TIMER);

#endif

}

void AlarmClass::begin(Timer::TIMER timer)

{

if (timer < lengthof(_instances))

{

_timer = timer;

_alarm_list = NULL;

_instances[_timer] = this;

Timer::begin(timer, Timer::CLOCK_1MHZ, false, true, false, TimerCallback);

}

bool AlarmClass::start(Alarm& alarm)

{

if (((int8)_timer < 0) || (alarm._interval < 1) || !alarm._handler)

return false;

uint32 save = System::disableAndSaveInterrupts();

if (add(alarm))

restart(_alarm_list->_alarm - System::micros64());

System::restoreInterrupts(save);

return true;

}

void AlarmClass::cancel(Alarm& alarm)

{

uint32 save = System::disableAndSaveInterrupts();

for (Alarm **p = &_alarm_list; *p; p = &(*p)->_next)

{

if (*p == &alarm)

{

*p = (*p)->_next;

break;

}

System::restoreInterrupts(save);

}

void AlarmClass::cancel(uint8 num, void *arg)

{

if ((num < lengthof(Alarm::_params)) && arg)

{

uint32 save = System::disableAndSaveInterrupts();

for (Alarm **p = &_alarm_list; *p; p = &(*p)->_next)

{

if ((*p)->_params[num] == arg)

{

*p = (*p)->_next;

break;

}

System::restoreInterrupts(save);

}

bool AlarmClass::add(Alarm& alarm)

{

Alarm **p;

for (p = &_alarm_list; *p && ((int64)((*p)->_alarm - alarm._alarm) <= 0); p = &(*p)->_next)

continue;

alarm._next = *p;

*p = &alarm;

return p == &_alarm_list;

}

void AlarmClass::TimerCallback(uint32 u32Device, uint32 u32ItemBitmap)

{

(void)u32Device; // E_AHI_DEVICE_TIMERx

(void)u32ItemBitmap; // E_AHI_TIMER_PERIOD_MASK or E_AHI_TIMER_RISE_MASK

_instances[Timer::id(u32Device)]->timeup();

}

void AlarmClass::timeup(void)

{

Alarm *p = NULL;

while (_alarm_list)

{

int64 t = _alarm_list->_alarm - System::micros64();

if (p || (t > 0))

{

restart(t);

return;

}

_alarm_list = (p = _alarm_list)->_next;

if (p->_handler(*p))

{

p->_alarm += p->_interval;

if (!add(*p))

p = NULL;

}

else

p = NULL;

}

void AlarmClass::restart(int64 interval)

{

uint16 n;

if (interval <= 1)

n = 2;

else if (interval & ~0xFFFF)

n = (uint16)-1000; // leave 1ms or more.

else

n = (uint16)interval;

Timer::startSingleShot(_timer, 0, n);

}

Alarm& Alarm::interval(int64 interval, bool fromnow)

{

if (fromnow)

_alarm = System::micros64() + interval;

_interval = interval;

return *this;

}

int64 Alarm::interval(void)

{

return _interval;

}

Alarm& Alarm::handler(Alarm::handler_t handler)

{

_handler = handler;

return *this;

}

Alarm::handler_t Alarm::handler(void)

{

return _handler;

}

Alarm& Alarm::param(uint8 num, void *val)

{

if (num < lengthof(_params))

_params[num] = val;

return *this;

}

void *Alarm::param(uint8 num)

{

return num < lengthof(_params) ? _params[num] : NULL;

}

bool Alarm::expire(void)

{

if ((int64)(System::micros64() - _alarm) < 0)

return false;

_alarm += _interval;

while ((int64)(System::micros64() - _alarm) >= 0);

return true;

}

次回は、WakeTimerの予定。

コメントを残す コメントをキャンセル

コメントを残すコメントをキャンセル