Sameera Nawarathne / SEEED_CAN

eeprom adding

Fork of SEEED_CAN by Sophie Dexter

seeed_can.h@3:29448355ef3a, 2017-03-10 (annotated)

Committer:
sameera0824
Date:
Fri Mar 10 09:32:20 2017 +0000
Revision:
3:29448355ef3a
Parent:
2:fd026fcfde94 
EEPROM chack

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Just4pLeisure 0:f5d099885d3d 1 /* seeed_can.h
Just4pLeisure 0:f5d099885d3d 2 * Copyright (c) 2013 Sophie Dexter
Just4pLeisure 0:f5d099885d3d 3 *
Just4pLeisure 0:f5d099885d3d 4 * Licensed under the Apache License, Version 2.0 (the "License");
Just4pLeisure 0:f5d099885d3d 5 * you may not use this file except in compliance with the License.
Just4pLeisure 0:f5d099885d3d 6 * You may obtain a copy of the License at
Just4pLeisure 0:f5d099885d3d 7 *
Just4pLeisure 0:f5d099885d3d 8 * http://www.apache.org/licenses/LICENSE-2.0
Just4pLeisure 0:f5d099885d3d 9 *
Just4pLeisure 0:f5d099885d3d 10 * Unless required by applicable law or agreed to in writing, software
Just4pLeisure 0:f5d099885d3d 11 * distributed under the License is distributed on an "AS IS" BASIS,
Just4pLeisure 0:f5d099885d3d 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Just4pLeisure 0:f5d099885d3d 13 * See the License for the specific language governing permissions and
Just4pLeisure 0:f5d099885d3d 14 * limitations under the License.
Just4pLeisure 0:f5d099885d3d 15 */
Just4pLeisure 0:f5d099885d3d 16 #ifndef _SEEED_CAN_H_
Just4pLeisure 0:f5d099885d3d 17 #define _SEEED_CAN_H_
Just4pLeisure 0:f5d099885d3d 18
Just4pLeisure 0:f5d099885d3d 19 #include "seeed_can_api.h"
Just4pLeisure 0:f5d099885d3d 20
Just4pLeisure 0:f5d099885d3d 21 // if print debug information
Just4pLeisure 0:f5d099885d3d 22 #define DEBUG
Just4pLeisure 0:f5d099885d3d 23
Just4pLeisure 0:f5d099885d3d 24 /** CANMessage class
Just4pLeisure 0:f5d099885d3d 25 */
Just4pLeisure 0:f5d099885d3d 26 class SEEED_CANMessage : public CAN_Message
Just4pLeisure 0:f5d099885d3d 27 {
Just4pLeisure 0:f5d099885d3d 28
Just4pLeisure 0:f5d099885d3d 29 public:
Just4pLeisure 0:f5d099885d3d 30 /** Creates empty CAN message.
Just4pLeisure 0:f5d099885d3d 31 */
Just4pLeisure 0:f5d099885d3d 32 SEEED_CANMessage() {
Just4pLeisure 0:f5d099885d3d 33 id = 0;
Just4pLeisure 0:f5d099885d3d 34 memset(data, 0, 8);
Just4pLeisure 0:f5d099885d3d 35 len = 8;
Just4pLeisure 0:f5d099885d3d 36 type = CANData;
Just4pLeisure 0:f5d099885d3d 37 format = CANStandard;
Just4pLeisure 0:f5d099885d3d 38 }
Just4pLeisure 0:f5d099885d3d 39
Just4pLeisure 0:f5d099885d3d 40 /** Creates CAN message with specific content.
Just4pLeisure 0:f5d099885d3d 41 */
Just4pLeisure 0:f5d099885d3d 42 SEEED_CANMessage(int _id, const char *_data, char _len = 8, CANType _type = CANData, CANFormat _format = CANStandard) {
Just4pLeisure 0:f5d099885d3d 43 id = _id;
Just4pLeisure 0:f5d099885d3d 44 memcpy(data, _data, _len);
Just4pLeisure 0:f5d099885d3d 45 len = _len & 0xF;
Just4pLeisure 0:f5d099885d3d 46 type = _type;
Just4pLeisure 0:f5d099885d3d 47 format = _format;
Just4pLeisure 0:f5d099885d3d 48 }
Just4pLeisure 0:f5d099885d3d 49
Just4pLeisure 0:f5d099885d3d 50 /** Creates CAN remote message.
Just4pLeisure 0:f5d099885d3d 51 */
Just4pLeisure 0:f5d099885d3d 52 SEEED_CANMessage(int _id, CANFormat _format = CANStandard) {
Just4pLeisure 0:f5d099885d3d 53 id = _id;
Just4pLeisure 0:f5d099885d3d 54 memset(data, 0, 8);
Just4pLeisure 0:f5d099885d3d 55 len = 0;
Just4pLeisure 0:f5d099885d3d 56 type = CANRemote;
Just4pLeisure 0:f5d099885d3d 57 format = _format;
Just4pLeisure 0:f5d099885d3d 58 }
Just4pLeisure 0:f5d099885d3d 59 };
Just4pLeisure 0:f5d099885d3d 60
Just4pLeisure 0:f5d099885d3d 61
Just4pLeisure 0:f5d099885d3d 62 /** A can bus client, used for communicating with Seeed Studios' CAN-BUS Arduino Shield.
Just4pLeisure 0:f5d099885d3d 63 */
Just4pLeisure 0:f5d099885d3d 64 class SEEED_CAN
Just4pLeisure 0:f5d099885d3d 65 {
Just4pLeisure 0:f5d099885d3d 66 public:
Just4pLeisure 1:ad71faa09868 67 /** Seeed Studios CAN-BUS Shield Constructor - Create a SEEED_CAN interface connected to the specified pins.
Just4pLeisure 0:f5d099885d3d 68 *
Just4pLeisure 2:fd026fcfde94 69 * The Seeed Studio CAN-BUS shield is an Arduino compatible shield and connects to the FRDM-KL25Z SPI0 interface using pins PTD2 (mosi) PTD3 (miso) PTD1 (clk). The Active low chip select normally connects to the FRDM-KL25Z's PTD0 pin, but there is an option on the Seeed Studio CAN-BUS shield to connect to the PTD5 pin. The CAN-BUS shield uses the FRDM-KL25Z's PTD4 pin for its (active low) interrupt capability. The defaults allow you to plug the Seeed Studios' CAN-BUS Shield into a FRDM-KL25Z mbed and it to work without specifying any parameters.
Just4pLeisure 0:f5d099885d3d 70 *
Just4pLeisure 2:fd026fcfde94 71 * @param ncs Active low chip select, @b default: @p SEEED_CAN_CS is FRDM-KL25Z PTD0 pin (p9 on LPC1768).
Just4pLeisure 2:fd026fcfde94 72 * @n If you change the link on the Seeed Studios CAN-BUS shield you should use a value of SEEED_CAN_IO9 or PTD5 instead.
Just4pLeisure 2:fd026fcfde94 73 * @param irq Active low interrupt pin, @b default: @p SEEED_CAN_IRQ is FRDM-KL25Z PTD4 pin (p10 on LPC1768).
Just4pLeisure 2:fd026fcfde94 74 * @param mosi SPI Master Out, Slave In pin, @b default: @p SEEED_CAN_MOSI is FRDM-KL25Z PTD2 pin (p11 on LPC1768).
Just4pLeisure 2:fd026fcfde94 75 * @param miso SPI Master In, Slave Out pin, @b default: :p SEEED_CAN_MISO is FRDM-KL25Z PTD3 pin (p12 on LPC1768).
Just4pLeisure 2:fd026fcfde94 76 * @param clk SPI Clock pin, @b default: @p SEEED_CAN_MISO is FRDM-KL25Z PTD1 pin (p13 on LPC1768).
Just4pLeisure 2:fd026fcfde94 77 * @param spiBitrate SPI Clock frequency, @b default: @p 1000000 (1 MHz).
Just4pLeisure 0:f5d099885d3d 78 */
Just4pLeisure 2:fd026fcfde94 79 #if defined MKL25Z4_H_ // defined in MKL25Z4.h
Just4pLeisure 1:ad71faa09868 80 SEEED_CAN(PinName ncs=SEEED_CAN_CS, PinName irq=SEEED_CAN_IRQ, PinName mosi=SEEED_CAN_MOSI, PinName miso=SEEED_CAN_MISO, PinName clk=SEEED_CAN_CLK, int spiBitrate=1000000);
Just4pLeisure 2:fd026fcfde94 81 #elif defined __LPC17xx_H__ // defined in LPC17xx.h
sameera0824 3:29448355ef3a 82 //SEEED_CAN(PinName ncs=p9, PinName irq=p10, PinName mosi=p11, PinName miso=p12, PinName clk=p13, int spiBitrate=1000000);
sameera0824 3:29448355ef3a 83 SEEED_CAN(PinName ncs=p11, PinName irq=p12, PinName mosi=p5, PinName miso=p6, PinName clk=p7, int spiBitrate=1000000);
Just4pLeisure 2:fd026fcfde94 84 #else // No default constructor for other...
Just4pLeisure 2:fd026fcfde94 85 SEEED_CAN(PinName ncs, PinName irq, PinName mosi, PinName miso, PinName clk, int spiBitrate=1000000);
Just4pLeisure 2:fd026fcfde94 86 #endif
Just4pLeisure 0:f5d099885d3d 87 // virtual ~SEEED_CAN(); // !!! Need a de-constructor for the interrrupt pin !!!
Just4pLeisure 0:f5d099885d3d 88
Just4pLeisure 2:fd026fcfde94 89 enum Mode {
Just4pLeisure 2:fd026fcfde94 90 Normal = 0,
Just4pLeisure 2:fd026fcfde94 91 Sleep,
Just4pLeisure 2:fd026fcfde94 92 Loopback,
Just4pLeisure 2:fd026fcfde94 93 Monitor,
Just4pLeisure 2:fd026fcfde94 94 Config,
Just4pLeisure 2:fd026fcfde94 95 Reset
Just4pLeisure 2:fd026fcfde94 96 };
Just4pLeisure 2:fd026fcfde94 97
Just4pLeisure 1:ad71faa09868 98 /** Open initialises the Seeed Studios CAN-BUS Shield.
Just4pLeisure 1:ad71faa09868 99 *
Just4pLeisure 2:fd026fcfde94 100 * @param canBitrate CAN Bus Clock frequency, @b default: @p 100000 (100 kHz).
Just4pLeisure 2:fd026fcfde94 101 * @param mode The initial operation mode, @b default: @p Normal.
Just4pLeisure 2:fd026fcfde94 102 * @n @p SEEED_CAN::Normal - Normal mode is the standard operating mode,
Just4pLeisure 2:fd026fcfde94 103 * @n @p SEEED_CAN::Monitor - This mode can be used for bus monitor applications.
Just4pLeisure 2:fd026fcfde94 104 * @n @p SEEED_CAN::Sleep - This mode can be used to minimize the current consumption,
Just4pLeisure 2:fd026fcfde94 105 * @n @p SEEED_CAN::Loopback - This mode can be used in system development and testing.
Just4pLeisure 2:fd026fcfde94 106 * @n @p SEEED_CAN::Config - Open with this mode to prevent unwanted messages being received while you configure Filters.
Just4pLeisure 1:ad71faa09868 107 *
Just4pLeisure 1:ad71faa09868 108 * @returns
Just4pLeisure 2:fd026fcfde94 109 * 1 if successful,
Just4pLeisure 2:fd026fcfde94 110 * @n 0 otherwise
Just4pLeisure 2:fd026fcfde94 111 */
Just4pLeisure 2:fd026fcfde94 112 int open(int canBitrate=100000, Mode mode = Normal);
Just4pLeisure 2:fd026fcfde94 113
Just4pLeisure 2:fd026fcfde94 114 /** Puts or removes the Seeed Studios CAN-BUS shield into or from silent monitoring mode.
Just4pLeisure 2:fd026fcfde94 115 *
Just4pLeisure 2:fd026fcfde94 116 * @param silent boolean indicating whether to go into silent mode or not.
Just4pLeisure 1:ad71faa09868 117 */
Just4pLeisure 2:fd026fcfde94 118 void monitor(bool silent);
Just4pLeisure 2:fd026fcfde94 119
Just4pLeisure 2:fd026fcfde94 120 /** Change the Seeed Studios CAN-BUS shield CAN operation mode.
Just4pLeisure 2:fd026fcfde94 121 *
Just4pLeisure 2:fd026fcfde94 122 * @param mode The new operation mode
Just4pLeisure 2:fd026fcfde94 123 * @n @p SEEED_CAN::Normal - Normal mode is the standard operating mode,
Just4pLeisure 2:fd026fcfde94 124 * @n @p SEEED_CAN::Monitor - This mode can be used for bus monitor applications.
Just4pLeisure 2:fd026fcfde94 125 * @n @p SEEED_CAN::Sleep - This mode can be used to minimize the current consumption,
Just4pLeisure 2:fd026fcfde94 126 * @n @p SEEED_CAN::Loopback - This mode can be used in system development and testing.
Just4pLeisure 2:fd026fcfde94 127 * @n @p SEEED_CAN::Reset - Reset the MCP2515 device and stay in Configuration mode.
Just4pLeisure 2:fd026fcfde94 128 *
Just4pLeisure 2:fd026fcfde94 129 * @returns
Just4pLeisure 2:fd026fcfde94 130 * 1 if mode change was successful
Just4pLeisure 2:fd026fcfde94 131 * @n 0 if mode change failed or unsupported,
Just4pLeisure 2:fd026fcfde94 132 */
Just4pLeisure 2:fd026fcfde94 133 int mode(Mode mode);
Just4pLeisure 1:ad71faa09868 134
Just4pLeisure 1:ad71faa09868 135 /** Set the CAN bus frequency (Bit Rate)
Just4pLeisure 0:f5d099885d3d 136 *
Just4pLeisure 0:f5d099885d3d 137 * @param hz The bus frequency in Hertz
Just4pLeisure 0:f5d099885d3d 138 *
Just4pLeisure 0:f5d099885d3d 139 * @returns
Just4pLeisure 2:fd026fcfde94 140 * 1 if successful,
Just4pLeisure 2:fd026fcfde94 141 * @n 0 otherwise
Just4pLeisure 0:f5d099885d3d 142 */
Just4pLeisure 1:ad71faa09868 143 int frequency(int canBitRate);
Just4pLeisure 0:f5d099885d3d 144
Just4pLeisure 1:ad71faa09868 145 /** Read a CAN bus message from the MCP2515 (if one has been received)
Just4pLeisure 1:ad71faa09868 146 *
Just4pLeisure 1:ad71faa09868 147 * @param msg A CANMessage to read to.
Just4pLeisure 1:ad71faa09868 148 *
Just4pLeisure 1:ad71faa09868 149 * @returns
Just4pLeisure 2:fd026fcfde94 150 * 1 if any messages have arrived
Just4pLeisure 2:fd026fcfde94 151 * @n 0 if no message arrived,
Just4pLeisure 1:ad71faa09868 152 */
Just4pLeisure 1:ad71faa09868 153 int read(SEEED_CANMessage &msg);
Just4pLeisure 1:ad71faa09868 154
Just4pLeisure 1:ad71faa09868 155 /** Write a CAN bus message to the MCP2515 (if there is a free message buffer)
Just4pLeisure 0:f5d099885d3d 156 *
Just4pLeisure 0:f5d099885d3d 157 * @param msg The CANMessage to write.
Just4pLeisure 0:f5d099885d3d 158 *
Just4pLeisure 0:f5d099885d3d 159 * @returns
Just4pLeisure 2:fd026fcfde94 160 * 1 if write was successful
Just4pLeisure 2:fd026fcfde94 161 * @n 0 if write failed,
Just4pLeisure 0:f5d099885d3d 162 */
Just4pLeisure 0:f5d099885d3d 163 int write(SEEED_CANMessage msg);
Just4pLeisure 0:f5d099885d3d 164
Just4pLeisure 0:f5d099885d3d 165 /** Configure one of the Accpetance Masks (0 or 1)
Just4pLeisure 0:f5d099885d3d 166 *
Just4pLeisure 0:f5d099885d3d 167 * @param maskNum The number of the Acceptance Mask to configure (Acceptance Mask 0 is associated with Filters 0 and 1, Acceptance Mask 1 is associated with Filters 2 through 5).
Just4pLeisure 0:f5d099885d3d 168 * @param canId CAN Id Mask bits (Acceptance Filters are only compared against bits that are set to '1' in an Acceptance Mask (e.g. mask 0x07F0 and filter 0x03F0 would allow through messages with CAN Id's 0x03F0 through 0x03FF because the 4 LSBs of the CAN Id are not filtered).
Just4pLeisure 2:fd026fcfde94 169 * @param format Describes if the Acceptance Mask is for a standard (CANStandard) or extended (CANExtended) CAN message frame format, @b default: @p CANStandard.
Just4pLeisure 0:f5d099885d3d 170 *
Just4pLeisure 0:f5d099885d3d 171 * @returns
Just4pLeisure 2:fd026fcfde94 172 * 1 if Acceptance Mask was set
Just4pLeisure 2:fd026fcfde94 173 * @n 0 if the Acceptance Mask could not be set
Just4pLeisure 0:f5d099885d3d 174 */
Just4pLeisure 1:ad71faa09868 175 int mask(int maskNum, int canId, CANFormat format = CANStandard);
Just4pLeisure 0:f5d099885d3d 176
Just4pLeisure 0:f5d099885d3d 177 /** Configure one of the Acceptance Filters (0 through 5)
Just4pLeisure 0:f5d099885d3d 178 *
Just4pLeisure 0:f5d099885d3d 179 * @param filterNum The number of the Acceptance Filter to configure (Acceptance Filters 0 and 1 are associated with Mask 0, Acceptance Filters 2 through 5 are associated with Mask 1).
Just4pLeisure 0:f5d099885d3d 180 * @param canId CAN Id Filter bits (Acceptance Filters are only compared against bits that are set to '1' in an Acceptance Mask (e.g. mask 0x07F0 and filter 0x03F0 would allow through messages with CAN Id's 0x03F0 through 0x03FF because the 4 LSBs of the CAN Id are not filtered).
Just4pLeisure 2:fd026fcfde94 181 * @param format Describes if the Acceptance Filter is for a standard (CANStandard) or extended (CANExtended) CAN message frame format, @b default: @p CANStandard.
Just4pLeisure 0:f5d099885d3d 182 *
Just4pLeisure 0:f5d099885d3d 183 * @returns
Just4pLeisure 2:fd026fcfde94 184 * 1 if Acceptance Filter was set
Just4pLeisure 2:fd026fcfde94 185 * @n 0 if the Acceptance Filter could not be set
Just4pLeisure 0:f5d099885d3d 186 */
Just4pLeisure 1:ad71faa09868 187 int filter(int filterNum, int canId, CANFormat format = CANStandard);
Just4pLeisure 0:f5d099885d3d 188
Just4pLeisure 0:f5d099885d3d 189 /** Returns number of message reception (read) errors to detect read overflow errors.
Just4pLeisure 1:ad71faa09868 190 *
Just4pLeisure 1:ad71faa09868 191 * @returns
Just4pLeisure 1:ad71faa09868 192 * Number of reception errors
Just4pLeisure 0:f5d099885d3d 193 */
Just4pLeisure 0:f5d099885d3d 194 unsigned char rderror(void);
Just4pLeisure 0:f5d099885d3d 195
Just4pLeisure 0:f5d099885d3d 196 /** Returns number of message transmission (write) errors to detect write overflow errors.
Just4pLeisure 1:ad71faa09868 197 *
Just4pLeisure 1:ad71faa09868 198 * @returns
Just4pLeisure 1:ad71faa09868 199 * Number of transmission errors
Just4pLeisure 0:f5d099885d3d 200 */
Just4pLeisure 0:f5d099885d3d 201 unsigned char tderror(void);
Just4pLeisure 0:f5d099885d3d 202
Just4pLeisure 2:fd026fcfde94 203 enum ErrorType {
Just4pLeisure 2:fd026fcfde94 204 AnyError = 0,
Just4pLeisure 2:fd026fcfde94 205 Errors,
Just4pLeisure 2:fd026fcfde94 206 Warnings,
Just4pLeisure 2:fd026fcfde94 207 Rx1Ovr,
Just4pLeisure 2:fd026fcfde94 208 Rx0Ovr,
Just4pLeisure 2:fd026fcfde94 209 TxBOff,
Just4pLeisure 2:fd026fcfde94 210 TxPasv,
Just4pLeisure 2:fd026fcfde94 211 RxPasv,
Just4pLeisure 2:fd026fcfde94 212 TxWarn,
Just4pLeisure 2:fd026fcfde94 213 RxWarn,
Just4pLeisure 2:fd026fcfde94 214 EWarn
Just4pLeisure 2:fd026fcfde94 215 };
Just4pLeisure 2:fd026fcfde94 216
Just4pLeisure 1:ad71faa09868 217 /** Check if any type of error has been detected on the CAN bus
Just4pLeisure 0:f5d099885d3d 218 *
Just4pLeisure 2:fd026fcfde94 219 * @param error Specify which type of error to report on, @b default: @p AnyError.
Just4pLeisure 2:fd026fcfde94 220 * @n @p SEEED_CAN::AnyError - Any one or more of the following errors and warnings:
Just4pLeisure 2:fd026fcfde94 221 * @n @p SEEED_CAN::Errors - Any one or more of the 5 errors:
Just4pLeisure 2:fd026fcfde94 222 * @n @p SEEED_CAN::Rx1Ovr - Receive Buffer 1 Overflow Flag bit,
Just4pLeisure 2:fd026fcfde94 223 * @n @p SEEED_CAN::Rx0Ovr - Receive Buffer 0 Overflow Flag bit,
Just4pLeisure 2:fd026fcfde94 224 * @n @p SEEED_CAN::TxBOff - Bus-Off Error Flag bit,
Just4pLeisure 2:fd026fcfde94 225 * @n @p SEEED_CAN::TxPasv - Transmit Error-Passive Flag bit,
Just4pLeisure 2:fd026fcfde94 226 * @n @p SEEED_CAN::RxPasv - Receive Error-Passive Flag bit,
Just4pLeisure 2:fd026fcfde94 227 * @n @p SEEED_CAN::Warnings - Any one or more of the 3 warnings:
Just4pLeisure 2:fd026fcfde94 228 * @n @p SEEED_CAN::TxWarn - Transmit Error Warning Flag bit,
Just4pLeisure 2:fd026fcfde94 229 * @n @p SEEED_CAN::RxWarn - Receive Error Warning Flag bit,
Just4pLeisure 2:fd026fcfde94 230 * @n @p SEEED_CAN::EWarn - Error Warning Flag bit.
Just4pLeisure 2:fd026fcfde94 231 *
Just4pLeisure 0:f5d099885d3d 232 * @returns
Just4pLeisure 2:fd026fcfde94 233 * 1 if specified type of error has been detected
Just4pLeisure 2:fd026fcfde94 234 * @n 0 if no errors
Just4pLeisure 0:f5d099885d3d 235 */
Just4pLeisure 2:fd026fcfde94 236 int errors(ErrorType type = AnyError);
Just4pLeisure 0:f5d099885d3d 237
Just4pLeisure 2:fd026fcfde94 238 /** Returns the contents of the MCP2515's Error Flag register
Just4pLeisure 0:f5d099885d3d 239 *
Just4pLeisure 0:f5d099885d3d 240 * @returns
Just4pLeisure 2:fd026fcfde94 241 * @b Bit_7 - RX1OVR: Receive Buffer 1 Overflow Flag bit - Set when a valid message is received for RXB1 and CANINTF.RX1IF = 1 - Must be reset by MCU,
Just4pLeisure 2:fd026fcfde94 242 * @n @b Bit_6 - RX0OVR: Receive Buffer 1 Overflow Flag bit - Set when a valid message is received for RXB0 and CANINTF.RX0IF = 1 - Must be reset by MCU,
Just4pLeisure 2:fd026fcfde94 243 * @n @b Bit_5 - TXBO: Bus-Off Error Flag bit - Bit set when TEC reaches 255 - Reset after a successful bus recovery sequence,
Just4pLeisure 2:fd026fcfde94 244 * @n @b Bit_4 - TXEP: Transmit Error-Passive Flag bit - Set when TEC is >= 128 - Reset when TEC is less than 128,
Just4pLeisure 2:fd026fcfde94 245 * @n @b Bit_3 - RXEP: Receive Error-Passive Flag bit - Set when REC is >= 128 - Reset when REC is less than 128,
Just4pLeisure 2:fd026fcfde94 246 * @n @b Bit_2 - TXWAR: Transmit Error Warning Flag bit - Set when TEC is >= 96 - Reset when TEC is less than 96,
Just4pLeisure 2:fd026fcfde94 247 * @n @b Bit_1 - RXWAR: Receive Error Warning Flag bit - Set when REC is >= 96 - Reset when REC is less than 96,
Just4pLeisure 2:fd026fcfde94 248 * @n @b Bit_0 - EWARN: Error Warning Flag bit - Set when TEC or REC is >= 96 (TXWAR or RXWAR = 1) - Reset when both REC and TEC are < 96.
Just4pLeisure 0:f5d099885d3d 249 */
Just4pLeisure 2:fd026fcfde94 250 unsigned char errorFlags(void);
Just4pLeisure 0:f5d099885d3d 251
Just4pLeisure 0:f5d099885d3d 252 enum IrqType {
Just4pLeisure 2:fd026fcfde94 253 None = 0,
Just4pLeisure 2:fd026fcfde94 254 AnyIrq,
Just4pLeisure 2:fd026fcfde94 255 RxAny,
Just4pLeisure 2:fd026fcfde94 256 TxAny,
Just4pLeisure 2:fd026fcfde94 257 Rx0Fill,
Just4pLeisure 2:fd026fcfde94 258 Rx1Full,
Just4pLeisure 2:fd026fcfde94 259 Tx0Free,
Just4pLeisure 2:fd026fcfde94 260 Tx1Free,
Just4pLeisure 2:fd026fcfde94 261 Tx2Free,
Just4pLeisure 2:fd026fcfde94 262 Error,
Just4pLeisure 2:fd026fcfde94 263 Wake,
Just4pLeisure 2:fd026fcfde94 264 MsgError,
Just4pLeisure 0:f5d099885d3d 265 };
Just4pLeisure 0:f5d099885d3d 266
Just4pLeisure 1:ad71faa09868 267 /** Attach a function to call whenever a CAN frame received interrupt is generated.
Just4pLeisure 0:f5d099885d3d 268 *
Just4pLeisure 2:fd026fcfde94 269 * @param fptr A pointer to a void function, or 0 to set as none.
Just4pLeisure 2:fd026fcfde94 270 * @param event Which CAN interrupt to attach the member function to, @b default: @p RxAny
Just4pLeisure 2:fd026fcfde94 271 * @n @p SEEED_CAN::None - Disable all interrupt sources,
Just4pLeisure 2:fd026fcfde94 272 * @n @p SEEED_CAN::AnyIrq - Enable all interrupt sources,
Just4pLeisure 2:fd026fcfde94 273 * @n @p SEEED_CAN::RxAny - Any full RX buffer can generate an interrupt,
Just4pLeisure 2:fd026fcfde94 274 * @n @p SEEED_CAN::TxAny - Any empty TX buffer can generate an interrupt,
Just4pLeisure 2:fd026fcfde94 275 * @n @p SEEED_CAN::Rx0Full - Receive buffer 1 full,
Just4pLeisure 2:fd026fcfde94 276 * @n @p SEEED_CAN::Rx1Full - Receive buffer 1 full,
Just4pLeisure 2:fd026fcfde94 277 * @n @p SEEED_CAN::Tx0Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 278 * @n @p SEEED_CAN::Tx1Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 279 * @n @p SEEED_CAN::Tx2Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 280 * @n @p SEEED_CAN::Error - Error (multiple sources in EFLG register),
Just4pLeisure 2:fd026fcfde94 281 * @n @p SEEED_CAN::Wake - Wakeup,
Just4pLeisure 2:fd026fcfde94 282 * @n @p SEEED_CAN::MsgError - Message Error,
Just4pLeisure 0:f5d099885d3d 283 */
Just4pLeisure 2:fd026fcfde94 284 void attach(void (*fptr)(void), IrqType event=RxAny);
Just4pLeisure 0:f5d099885d3d 285
Just4pLeisure 1:ad71faa09868 286 /** Attach a member function to call whenever a CAN frame received interrupt is generated.
Just4pLeisure 0:f5d099885d3d 287 *
Just4pLeisure 2:fd026fcfde94 288 * @param tptr pointer to the object to call the member function on.
Just4pLeisure 2:fd026fcfde94 289 * @param mptr pointer to the member function to be called.
Just4pLeisure 2:fd026fcfde94 290 * @param event Which CAN interrupt to attach the member function to, @b default: @p RxAny
Just4pLeisure 2:fd026fcfde94 291 * @n @p SEEED_CAN::None - Disable all interrupt sources,
Just4pLeisure 2:fd026fcfde94 292 * @n @p SEEED_CAN::AnyIrq - Enable all interrupt sources,
Just4pLeisure 2:fd026fcfde94 293 * @n @p SEEED_CAN::RxAny - Any full RX buffer can generate an interrupt,
Just4pLeisure 2:fd026fcfde94 294 * @n @p SEEED_CAN::TxAny - Any empty TX buffer can generate an interrupt,
Just4pLeisure 2:fd026fcfde94 295 * @n @p SEEED_CAN::Rx0Full - Receive buffer 1 full,
Just4pLeisure 2:fd026fcfde94 296 * @n @p SEEED_CAN::Rx1Full - Receive buffer 1 full,
Just4pLeisure 2:fd026fcfde94 297 * @n @p SEEED_CAN::Tx0Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 298 * @n @p SEEED_CAN::Tx1Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 299 * @n @p SEEED_CAN::Tx2Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 300 * @n @p SEEED_CAN::Error - Error (multiple sources in EFLG register),
Just4pLeisure 2:fd026fcfde94 301 * @n @p SEEED_CAN::Wake - Wakeup,
Just4pLeisure 2:fd026fcfde94 302 * @n @p SEEED_CAN::MsgError - Message Error,
Just4pLeisure 0:f5d099885d3d 303 */
Just4pLeisure 0:f5d099885d3d 304 template<typename T>
Just4pLeisure 2:fd026fcfde94 305 void attach(T* tptr, void (T::*mptr)(void), IrqType event=RxAny) {
Just4pLeisure 1:ad71faa09868 306 _callback_irq.attach(tptr, mptr);
Just4pLeisure 2:fd026fcfde94 307 mcpSetInterrupts(&_can, (CANIrqs)event);
Just4pLeisure 2:fd026fcfde94 308 if((mptr != NULL) && (tptr != NULL)) {
Just4pLeisure 2:fd026fcfde94 309 _callback_irq.attach(tptr, mptr);
Just4pLeisure 2:fd026fcfde94 310 mcpSetInterrupts(&_can, (CANIrqs)event);
Just4pLeisure 2:fd026fcfde94 311 // _irq[type].attach(tptr, mptr);
Just4pLeisure 2:fd026fcfde94 312 // can_irq_set(&_can, (CanIrqType)type, 1);
Just4pLeisure 2:fd026fcfde94 313 } else {
Just4pLeisure 2:fd026fcfde94 314 mcpSetInterrupts(&_can, (CANIrqs)SEEED_CAN::None);
Just4pLeisure 2:fd026fcfde94 315 // can_irq_set(&_can, (CanIrqType)type, 0);
Just4pLeisure 2:fd026fcfde94 316 }
Just4pLeisure 0:f5d099885d3d 317 }
Just4pLeisure 0:f5d099885d3d 318
Just4pLeisure 2:fd026fcfde94 319 void call_irq(void);
Just4pLeisure 1:ad71faa09868 320
Just4pLeisure 2:fd026fcfde94 321 /** Check if the specified interrupt event has occurred
Just4pLeisure 2:fd026fcfde94 322 *
Just4pLeisure 2:fd026fcfde94 323 * @param event Which CAN interrupt to attach the member function to
Just4pLeisure 2:fd026fcfde94 324 * @n @p SEEED_CAN::RxAny - At least 1 RX buffer is full,
Just4pLeisure 2:fd026fcfde94 325 * @n @p SEEED_CAN::TxAny - At least 1 TX buffer is empty,
Just4pLeisure 2:fd026fcfde94 326 * @n @p SEEED_CAN::Rx0Full - Receive buffer 1 full,
Just4pLeisure 2:fd026fcfde94 327 * @n @p SEEED_CAN::Rx1Full - Receive buffer 1 full,
Just4pLeisure 2:fd026fcfde94 328 * @n @p SEEED_CAN::Tx0Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 329 * @n @p SEEED_CAN::Tx1Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 330 * @n @p SEEED_CAN::Tx2Free - Transmit buffer 2 empty,
Just4pLeisure 2:fd026fcfde94 331 * @n @p SEEED_CAN::Error - Error (multiple sources in EFLG register),
Just4pLeisure 2:fd026fcfde94 332 * @n @p SEEED_CAN::Wake - Wakeup,
Just4pLeisure 2:fd026fcfde94 333 * @n @p SEEED_CAN::MsgError - Message Error,
Just4pLeisure 2:fd026fcfde94 334 *
Just4pLeisure 2:fd026fcfde94 335 * @returns
Just4pLeisure 2:fd026fcfde94 336 * 1 if specified interrupt event has occurred
Just4pLeisure 2:fd026fcfde94 337 * @n 0 if no errors
Just4pLeisure 2:fd026fcfde94 338 */
Just4pLeisure 2:fd026fcfde94 339 int interrupts(IrqType type);
Just4pLeisure 2:fd026fcfde94 340
Just4pLeisure 2:fd026fcfde94 341 /** Returns the contents of the MCP2515's Interrupt Flag register
Just4pLeisure 2:fd026fcfde94 342 *
Just4pLeisure 2:fd026fcfde94 343 * @returns
Just4pLeisure 2:fd026fcfde94 344 * @b Bit_7 - MERRF: Message Error Interrupt Flag,
Just4pLeisure 2:fd026fcfde94 345 * @n @b Bit_6 - WAKIF: Wake-up Interrupt Flag,
Just4pLeisure 2:fd026fcfde94 346 * @n @b Bit_5 - ERRIF: Error Interrupt Flag (multiple sources in EFLG register, see errorFlags)
Just4pLeisure 2:fd026fcfde94 347 * @n @b Bit_4 - TX2IF: Transmit Buffer 2 Empty Interrupt Flag
Just4pLeisure 2:fd026fcfde94 348 * @n @b Bit_3 - TX1IF: Transmit Buffer 1 Empty Interrupt Flag
Just4pLeisure 2:fd026fcfde94 349 * @n @b Bit_2 - TX0IF: Transmit Buffer 0 Empty Interrupt Flag
Just4pLeisure 2:fd026fcfde94 350 * @n @b Bit_1 - RX1IF: Receive Buffer 1 Full Interrupt Flag
Just4pLeisure 2:fd026fcfde94 351 * @n @b Bit_0 - RX0IF: Receive Buffer 0 Full Interrupt Flag
Just4pLeisure 2:fd026fcfde94 352 * @n Bits are set (1) when interrupt pending, clear (0) when no interrupt pending.
Just4pLeisure 2:fd026fcfde94 353 * @n Bits must be cleared by MCU to reset interrupt condition.
Just4pLeisure 2:fd026fcfde94 354 */
Just4pLeisure 2:fd026fcfde94 355 unsigned char interruptFlags(void);
Just4pLeisure 2:fd026fcfde94 356
Just4pLeisure 0:f5d099885d3d 357 protected:
Just4pLeisure 1:ad71faa09868 358 SPI _spi;
Just4pLeisure 2:fd026fcfde94 359 mcp_can_t _can;
Just4pLeisure 2:fd026fcfde94 360 InterruptIn _irqpin;
Just4pLeisure 1:ad71faa09868 361 FunctionPointer _callback_irq;
Just4pLeisure 0:f5d099885d3d 362
Just4pLeisure 0:f5d099885d3d 363 };
Just4pLeisure 0:f5d099885d3d 364
Just4pLeisure 0:f5d099885d3d 365 #endif // SEEED_CAN_H