Diff: drivers/CAN.cpp

Revision:

187:0387e8f68319

Parent:

184:08ed48f1de7f

Child:

188:bcfe06ba3d64

--- a/drivers/CAN.cpp	Fri Jun 22 16:45:37 2018 +0100
+++ b/drivers/CAN.cpp	Thu Sep 06 13:40:20 2018 +0100
@@ -22,7 +22,8 @@
 
 namespace mbed {
 
-CAN::CAN(PinName rd, PinName td) : _can(), _irq() {
+CAN::CAN(PinName rd, PinName td) : _can(), _irq()
+{
     // No lock needed in constructor
 
     for (size_t i = 0; i < sizeof _irq / sizeof _irq[0]; i++) {
@@ -33,7 +34,8 @@
     can_irq_init(&_can, (&CAN::_irq_handler), (uint32_t)this);
 }
 
-CAN::CAN(PinName rd, PinName td, int hz) : _can(), _irq() {
+CAN::CAN(PinName rd, PinName td, int hz) : _can(), _irq()
+{
     // No lock needed in constructor
 
     for (size_t i = 0; i < sizeof _irq / sizeof _irq[0]; i++) {
@@ -44,7 +46,8 @@
     can_irq_init(&_can, (&CAN::_irq_handler), (uint32_t)this);
 }
 
-CAN::~CAN() {
+CAN::~CAN()
+{
     // No lock needed in destructor
 
     // Detaching interrupts releases the sleep lock if it was locked
@@ -55,68 +58,78 @@
     can_free(&_can);
 }
 
-int CAN::frequency(int f) {
+int CAN::frequency(int f)
+{
     lock();
     int ret = can_frequency(&_can, f);
     unlock();
     return ret;
 }
 
-int CAN::write(CANMessage msg) {
+int CAN::write(CANMessage msg)
+{
     lock();
     int ret = can_write(&_can, msg, 0);
     unlock();
     return ret;
 }
 
-int CAN::read(CANMessage &msg, int handle) {
+int CAN::read(CANMessage &msg, int handle)
+{
     lock();
     int ret = can_read(&_can, &msg, handle);
     unlock();
     return ret;
 }
 
-void CAN::reset() {
+void CAN::reset()
+{
     lock();
     can_reset(&_can);
     unlock();
 }
 
-unsigned char CAN::rderror() {
+unsigned char CAN::rderror()
+{
     lock();
     int ret = can_rderror(&_can);
     unlock();
     return ret;
 }
 
-unsigned char CAN::tderror() {
+unsigned char CAN::tderror()
+{
     lock();
     int ret = can_tderror(&_can);
     unlock();
     return ret;
 }
 
-void CAN::monitor(bool silent) {
+void CAN::monitor(bool silent)
+{
     lock();
     can_monitor(&_can, (silent) ? 1 : 0);
     unlock();
 }
 
-int CAN::mode(Mode mode) {
+int CAN::mode(Mode mode)
+{
     lock();
     int ret = can_mode(&_can, (CanMode)mode);
     unlock();
     return ret;
 }
 
-int CAN::filter(unsigned int id, unsigned int mask, CANFormat format, int handle) {
+int CAN::filter(unsigned int id, unsigned int mask, CANFormat format, int handle)
+{
     lock();
     int ret = can_filter(&_can, id, mask, format, handle);
     unlock();
     return ret;
 }
 
-void CAN::attach(Callback<void()> func, IrqType type) {
+void CAN::attach(Callback<void()> func, IrqType type)
+{
     lock();
     if (func) {
         // lock deep sleep only the first time
@@ -136,18 +149,21 @@
     unlock();
 }
 
-void CAN::_irq_handler(uint32_t id, CanIrqType type) {
-    CAN *handler = (CAN*)id;
+void CAN::_irq_handler(uint32_t id, CanIrqType type)
+{
+    CAN *handler = (CAN *)id;
     if (handler->_irq[type]) {
         handler->_irq[type].call();
     }
 }
 
-void CAN::lock() {
+void CAN::lock()
+{
     _mutex.lock();
 }
 
-void CAN::unlock() {
+void CAN::unlock()
+{
     _mutex.unlock();
 }