Axeda Corp
Axeda Ready Demo for Freescale FRDM-KL46Z as accident alert system
Dependencies: FRDM_MMA8451Q KL46Z-USBHost MAG3110 SocketModem TSI mbed FATFileSystem
Fork of
AxedaGo-Freescal_FRDM-KL46Z
by 
Axeda Corp
Diff: AMMPC/axTransport.cpp
- Revision:
- 0:65004368569c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/AMMPC/axTransport.cpp Tue Jul 01 21:31:54 2014 +0000
@@ -0,0 +1,291 @@
+#include "axTransport.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "axStatusCodes.h"
+#include "axConstants.h"
+#include <math.h>
+#include "include_me.h"
+#include "mbed.h"
+
+using namespace mts;
+char *temp_buff;
+int buff_size;
+
+/************************************************************************************************/
+/*getEpoch() */
+/* */
+/*This method should return the number of seconds since January 1st 1970. */
+/* */
+/*returns long value in seconds */
+/************************************************************************************************/
+long getEpoch(){
+ return (long)0;
+ }
+
+
+/**************************************************************************************************/
+/*ax_print() */
+/* */
+/*A wrapper method that will allow you to direct the output to a particular stream. Most of the */
+/*time the output will just go to printf/std. out. This is called by the axAgent library to print*/
+/*error and debug messages. It is reccomended to include processing for the integers AX_DEBUG_MSG*/
+/*and AX_ERROR_MSG as the library will frequently use these options if configured. */
+/* */
+/* msgType: allows for an integer value to control how the data is displayed or written */
+/* msg: a pointer to a string containing the data to be printed */
+/************************************************************************************************/
+void ax_print(int msgType, char *msg){
+ switch(msgType) {
+ case AX_DEBUG_MSG:
+ printf("DEBUG: %s\n", msg);
+ break;
+ case AX_ERROR_MSG:
+ printf("ERR: %s\n", msg);
+ break;
+ }
+
+ }
+/************************************************************************************************/
+/*sys_delay() */
+/* */
+/*A wrapper method that is meant to induce a delay on the system that it running it. Used mostly*/
+/*to implement timeouts. */
+/* */
+/* */
+/* */
+/************************************************************************************************/
+void sys_delay(int seconds){
+
+ }
+
+/************************************************************************************************/
+/*randInt() */
+/* */
+/*This function is an abstraction function and should be populated with a call to the host's */
+/*equivalent of the random function. */
+/************************************************************************************************/
+int randInt() {
+ //call to the local create random method.
+ srand(1235);
+ return rand();
+ }
+
+/************************************************************************************************/
+/*seedRand() */
+/* */
+/*This function is an abstraction function and should be populated with a call to the host's */
+/*equivalent of the function that seeds the random number generator */
+/************************************************************************************************/
+int seedRand(){
+
+
+ }
+
+/*************************************************************************************************/
+/*net_socketInit() */
+/* */
+/*This method provides a convenient way to call code that initializes the socket before it is */
+/*actually called to open. For example, it could initialize a holder object that you code or set */
+/*options on the socket itself. The return will be a code that could be passed up through the */
+/*HTTP library and to the error stream. */
+/*************************************************************************************************/
+int net_socketInit(ax_socket *sock) {
+ int retVal=AX_UNKNOWN;
+
+ buff_size=0;
+ temp_buff=NULL;
+
+ return retVal;
+ }
+
+/*************************************************************************************************/
+/*net_socketOpen() */
+/* */
+/*This function opens a network port and connects to it. The connection point is defined by server*/
+/*and port in the arguments. A reference to the port should be stored in the sock structure. If */
+/*the secure flag is set to AX_TRUE your code should enable TLS or SSL at this stage. */
+/* */
+/*************************************************************************************************/
+int net_socketOpen(ax_socket *sock, char *server, int port, int secure){
+ int retVal=AX_UNKNOWN;
+
+ Wifi* wifi = Wifi::getInstance();
+ // Mode mode=TCP;
+ bool result=wifi->open(server, port, Wifi::TCP);
+// bool result=wifi->open("192.168.1.107", port, Wifi::TCP);
+ if(result) {
+ retVal=AX_OK;
+ }
+ else {retVal=AX_NET_ERR_UNABLE_TO_CONNECT; }
+
+ return retVal;
+ }
+/*************************************************************************************************/
+/*net_socketWrite() */
+/* */
+/*This function is used to write the data to a network port that has already been open and is */
+/*connected. As usual the ax_socket struct should contain a reference to your port that you wish */
+/*to write to. Data contains the data to be written and size describes how long the data is. */
+/* */
+/*************************************************************************************************/
+int net_socketWrite(ax_socket *sock, char *data, int size) {
+ int retVal=AX_OK;
+// Wifi* wifi = Wifi::getInstance();
+// int written= wifi->write(data, size, 300);
+ int fullsz=size+1;
+ if(buff_size==0) {
+ temp_buff=(char *)calloc(fullsz, sizeof(char));
+ int wrt=snprintf(temp_buff, fullsz, "%s", data);
+ buff_size++;
+ }
+ else {
+ int total=strlen(temp_buff)+fullsz;
+ char *temp=(char *)calloc(total, sizeof(char));
+ snprintf(temp, total, "%s%s", temp_buff, data);
+ free(temp_buff);
+ temp_buff=temp;
+ buff_size++;
+ }
+
+ return retVal;
+ }
+
+
+/*************************************************************************************************/
+/*net_socketFlush() */
+/* */
+/*This function will be called to handle writing all the data out to a network port. This function*/
+/*may not be needed depending on your system. The single argument is a pointer to a struct that */
+/*should contain the necessary references to the port on your local system. */
+/* */
+/*************************************************************************************************/
+int net_socketFlush(ax_socket *sock){
+ int retVal=AX_UNKNOWN;
+ int size=strlen(temp_buff);
+
+ Wifi* wifi = Wifi::getInstance();
+ wifi->write(temp_buff, size, 300); //Wr
+
+ free(temp_buff);
+ buff_size=0;
+
+ return retVal;
+ }
+/*************************************************************************************************/
+/*net_socketClose() */
+/* */
+/*This function will be called to handle a socket close operation. It is used primarily by the */
+/*axHTTP part of the library. The single argument is pointer to a structure that should contain */
+/*the necessary references to the port on your local system. */
+/*Override the source in this function to close a network port */
+/*************************************************************************************************/
+int net_socketClose(ax_socket *sock){
+ // int retVal=AX_UNKNOWN;
+ Wifi* wifi = Wifi::getInstance();
+ wifi->close();
+ int ctr=30;
+
+ while((wifi->isOpen()==true)&&(ctr>0)) {
+ wifi->close();
+ printf("Socket Not closed, %d\n", ctr);
+ ctr--;
+ wait(1);
+ }
+
+ return AX_OK;
+ }
+
+/*************************************************************************************************/
+/*net_socketRead() */
+/* */
+/*This function is a wrapper function that will read returned data from a previous web call. It */
+/*is assumed that any connection related to ax_socket will have already been established. The */
+/*function should read the data and store it into the *data pointer, then populate the number of */
+/*bytes read in the size variable. The axHTTP library will handle parsing and making sense of the*/
+/*data that it is provided. The timeout will be passed as a parameter but is not implemented by */
+/*any of the calling libraries, implement it here or pass to another local function if available.*/
+/*************************************************************************************************/
+int net_socketRead(ax_socket *sock, int timeout, unsigned char *buffer, int bufferSz, int *readSz){
+ int retVal=AX_UNKNOWN;
+ Wifi* wifi = Wifi::getInstance();
+ int bytesRead = wifi->read((char *)buffer, bufferSz, 300);
+ *readSz=bytesRead;
+ if(bytesRead>0) {return AX_OK; }
+
+ return retVal;
+ }
+
+/*************************************************************************************************/
+/*scm_download_req() */
+/* */
+/*This function will be called whenever an egress message is recieved with a file download command*/
+/*You can write the code in the function to handle the file immediately OR store the structure for*/
+/*later processing. The latter is preferable as this request may prevent the network port from */
+/*being closed in a timely fashion. */
+/* */
+/*************************************************************************************************/
+int scm_download_req(ax_package *request) {
+
+
+}
+
+
+/*************************************************************************************************/
+/*scm_file_write() */
+/* */
+/*This function will be called whenever a file download is requested from the system. Override the*/
+/*function to direct the output to serial or a file system or other storage device of your choice*/
+/*The parameters to the function will be filled in when it's called by the toolkit */
+/* */
+/*char *filename: Just what it sounds like, the file name of the file */
+/*char *data: The actual data of the file. */
+/*int length: The number of bytes received */
+/*ax_package_instruction *downloadInfo: a struct containing filename/path etc. */
+/*************************************************************************************************/
+int scm_file_write(char *filename, char *data, int length, ax_package_instruction *downloadInfo){
+
+
+ return AX_OK;
+ }
+
+
+
+/*************************************************************************************************/
+/*data_item_write() */
+/* */
+/*If a set data item command is recieved from the platform server this function will be called to*/
+/*handle it each time. The function is here to allow for external data to be modified as needed. */
+/*It could toggle a pin and light up an led or set a global variable in another thread. */
+/* */
+/*char *name: The name of the data item on the platform */
+/*int ax_type: {AX_STRING|AX_ANALoG|AX_DIGITAL} indicates whether the sValue or dValue parameter */
+/* will have the intended data. */
+/*char *sValue: if ax_type==AX_STRING then this will be a pointer to a valid cstring */
+/*int dValue: if ax_type==AX_ANLOG|AX_DIGITAL this value will be populated. It should be not be */
+/* checked if the type is AX_STRING */
+/*************************************************************************************************/
+int data_item_write(char *name, char *sValue, int dValue, int ax_type) {
+
+return AX_OK;
+}
+
+/*************************************************************************************************/
+/*data_item_request() */
+/* */
+/*This function is called whenever the platform requests a data item's current value. Since this */
+/*library is designed to run as it's own thread it does not maintain a list of data items and */
+/*values. The implementation of this function should call an appropriate library or check an input*/
+/*then create a dataItem set and send it immediately or on the next ping. */
+/* */
+/*char *name, the name of the data item being requested */
+/* */
+/*************************************************************************************************/
+int data_item_request(char *name) {
+
+return AX_OK;
+}
+
+/***************************************************************************************************/
+/***********************************************{Custom helper methods}****************************/