Add ListMessages() and SupportedStorageAreas().

Author: barnybug

examples/receive.go

@@ -0,0 +1,31 @@
+// Example of receiving messages.
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/barnybug/gogsmmodem"
+	"github.com/tarm/goserial"
+)
+
+func main() {
+	conf := serial.Config{Name: "/dev/ttyUSB1", Baud: 115200}
+	modem, err := gogsmmodem.Open(&conf, true)
+	if err != nil {
+		panic(err)
+	}
+
+	for packet := range modem.OOB {
+		log.Printf("Received: %#v\n", packet)
+		switch p := packet.(type) {
+		case gogsmmodem.MessageNotification:
+			log.Println("Message notification:", p)
+			msg, err := modem.GetMessage(p.Index)
+			if err == nil {
+				fmt.Printf("Message from %s: %s\n", msg.Telephone, msg.Body)
+				modem.DeleteMessage(p.Index)
+			}
+		}
+	}
+}

examples/stored.go

@@ -0,0 +1,23 @@
+// Example of retrieving stored messages.
+package main
+
+import (
+	"fmt"
+
+	"github.com/barnybug/gogsmmodem"
+	"github.com/tarm/goserial"
+)
+
+func main() {
+	conf := serial.Config{Name: "/dev/ttyUSB1", Baud: 115200}
+	modem, err := gogsmmodem.Open(&conf, true)
+	if err != nil {
+		panic(err)
+	}
+
+	li, _ := modem.ListMessages("ALL")
+	fmt.Printf("%d stored messages\n", len(*li))
+	for _, msg := range *li {
+		fmt.Println(msg.Index, msg.Status, msg.Body)
+	}
+}

gsm.go

@@ -60,6 +60,7 @@ func (self *Modem) Close() error {
 
 // Commands
 
+// GetMessage by index n from memory.
 func (self *Modem) GetMessage(n int) (*Message, error) {
 	packet, err := self.send("+CMGR", n)
 	if err != nil {
@@ -71,6 +72,44 @@ func (self *Modem) GetMessage(n int) (*Message, error) {
 	return nil, errors.New("Message not found")
 }
 
+// ListMessages stored in memory. Filter should be "ALL", "REC UNREAD", "REC READ", etc.
+func (self *Modem) ListMessages(filter string) (*MessageList, error) {
+	packet, err := self.send("+CMGL", filter)
+	if err != nil {
+		return nil, err
+	}
+	res := MessageList{}
+	if _, ok := packet.(OK); ok {
+		// empty response
+		return &res, nil
+	}
+
+	for {
+		if msg, ok := packet.(Message); ok {
+			res = append(res, msg)
+			if msg.Last {
+				break
+			}
+		} else {
+			return nil, errors.New("Unexpected error")
+		}
+
+		packet = <-self.rx
+	}
+	return &res, nil
+}
+
+func (self *Modem) SupportedStorageAreas() (*StorageAreas, error) {
+	packet, err := self.send("+CPMS", "?")
+	if err != nil {
+		return nil, err
+	}
+	if msg, ok := packet.(StorageAreas); ok {
+		return &msg, nil
+	}
+	return nil, errors.New("Unexpected response type")
+}
+
 func (self *Modem) DeleteMessage(n int) error {
 	_, err := self.send("+CMGD", n)
 	return err
@@ -100,11 +139,20 @@ func lineChannel(r io.Reader) chan string {
 var reQuestion = regexp.MustCompile(`AT(\+[A-Z]+)`)
 
 func parsePacket(status string, header string, body string) Packet {
+	if header == "" && (status == "OK" || status == "ERROR") {
+		if status == "OK" {
+			return OK{}
+		} else {
+			return ERROR{}
+		}
+	}
+
 	ls := strings.SplitN(header, ":", 2)
 	if len(ls) != 2 {
 		return UnknownPacket{header, []interface{}{}}
 	}
-	args := unquotes(strings.TrimSpace(ls[1]))
+	uargs := strings.TrimSpace(ls[1])
+	args := unquotes(uargs)
 	switch ls[0] {
 	case "+ZUSIMR":
 		// message storage unset nag, ignore
@@ -120,6 +168,46 @@ func parsePacket(status string, header string, body string) Packet {
 	case "+CMGR":
 		return Message{Status: args[0].(string), Telephone: args[1].(string),
 			Timestamp: parseTime(args[3].(string)), Body: body}
+	case "+CMGL":
+		return Message{
+			Index:     args[0].(int),
+			Status:    args[1].(string),
+			Telephone: args[2].(string),
+			Timestamp: parseTime(args[4].(string)),
+			Body:      body,
+			Last:      status != "",
+		}
+	case "+CPMS":
+		s := uargs
+		if strings.HasPrefix(s, "(") {
+			// query response
+			// ("A","B","C"),("A","B","C"),("A","B","C")
+			s = strings.TrimPrefix(s, "(")
+			s = strings.TrimSuffix(s, ")")
+			areas := strings.SplitN(s, "),(", 3)
+			return StorageAreas{
+				stringsUnquotes(areas[0]),
+				stringsUnquotes(areas[1]),
+				stringsUnquotes(areas[2]),
+			}
+		} else {
+			// set response
+			// 0,100,0,100,0,100
+			// get ints
+			var iargs []int
+			for _, arg := range args {
+				if iarg, ok := arg.(int); ok {
+					iargs = append(iargs, iarg)
+				}
+			}
+			if len(iargs) != 6 {
+				break
+			}
+
+			return StorageInfo{
+				iargs[0], iargs[1], iargs[2], iargs[3], iargs[4], iargs[5],
+			}
+		}
 	case "":
 		if status == "OK" {
 			return OK{}
@@ -139,7 +227,13 @@ func (self *Modem) listen() {
 			if line == echo {
 				continue // ignore echo of command
 			} else if last != "" && startsWith(line, last) {
+				if header != "" {
+					// first of multiple responses (eg CMGL)
+					packet := parsePacket("", header, body)
+					self.rx <- packet
+				}
 				header = line
+				body = ""
 			} else if line == "OK" || line == "ERROR" {
 				packet := parsePacket(line, header, body)
 				self.rx <- packet
@@ -207,13 +301,13 @@ func (self *Modem) init() error {
 		return err
 	}
 	log.Println("Echo off")
-	// set SMS storage
-	// note: seems to deliver to SM (SIM) storage regardless, so need to set
-	// READ to "SM" too.
-	if _, err := self.send("+CPMS", "SM", "SM", "SM"); err != nil {
+	// use combined storage (MT)
+	msg, err := self.send("+CPMS", "SM", "SM", "SM")
+	if err != nil {
 		return err
 	}
-	log.Println("Set SMS Storage")
+	sinfo := msg.(StorageInfo)
+	log.Printf("Set SMS Storage: %d/%d used\n", sinfo.UsedSpace1, sinfo.MaxSpace1)
 	// set SMS text mode - easiest to implement. Ignore response which is
 	// often a benign error.
 	self.send("+CMGF", 1)
@@ -233,6 +327,5 @@ func (self *Modem) init() error {
 		return err
 	}
 	log.Println("Set SMSC to:", smsc.Args)
-	// fmt.Println(r)
 	return nil
 }

gsm_test.go

@@ -3,6 +3,7 @@ package gogsmmodem
 import (
 	"fmt"
 	"io"
+	"log"
 	"reflect"
 	"testing"
 	"time"
@@ -16,7 +17,7 @@ var initReplay = []string{
 	"->ATE0\r\n",
 	"<-ATE0\n",
 	"<-\r\nOK\r\n",
-	"->AT+CPMS=\"SM\",\"SM\",\"SM\"\r\n",
+	"->AT+CPMS=\"MT\",\"MT\",\"MT\"\r\n",
 	"<-\r\n+CPMS: 50,50,50,50,50,50\r\nOK\n\n",
 	"->AT+CMGF=1\r\n",
 	"<-\r\nOK\r\n",
@@ -137,7 +138,7 @@ func TestGetMessage(t *testing.T) {
 	}
 
 	msg, _ := modem.GetMessage(1)
-	expected := Message{"REC UNREAD", "+441234567890", time.Date(2014, 2, 1, 15, 7, 43, 0, time.UTC), "Hi"}
+	expected := Message{0, "REC UNREAD", "+441234567890", time.Date(2014, 2, 1, 15, 7, 43, 0, time.UTC), "Hi", false}
 	if *msg != expected {
 		t.Errorf("Expected: %#v, got %#v", expected, msg)
 	}
@@ -189,3 +190,87 @@ func TestSendMessage(t *testing.T) {
 	}
 	modem.Close()
 }
+
+var listMessagesReplay = []string{
+	"->AT+CMGL=\"ALL\"\r\n",
+	"<-\r\n+CMGL: 0,\"REC UNREAD\",\"+441234567890\",,\"14/02/01,15:07:43+00\"\r\nHi\r\n+CMGL: 1,\"REC READ\",\"+441234567890\",,\"14/02/01,15:07:43+00\"\r\nOla\r\n+CMGL: 2,\"REC UNREAD\",\"+44123456",
+	"<-7890\",,\"14/02/01,15:07:43+00\"\r\nJa\r\n\r\nOK\r\n",
+}
+
+func TestListMessages(t *testing.T) {
+	OpenPort = func(config *serial.Config) (io.ReadWriteCloser, error) {
+		replay := appendLists(initReplay, listMessagesReplay)
+		return NewMockSerialPort(replay), nil
+	}
+	modem, err := Open(&serial.Config{}, true)
+	if err != nil {
+		t.Error("Expected: no error, got:", err)
+	}
+
+	msg, _ := modem.ListMessages("ALL")
+	expected := MessageList{
+		Message{0, "REC UNREAD", "+441234567890", time.Date(2014, 2, 1, 15, 7, 43, 0, time.UTC), "Hi", false},
+		Message{1, "REC READ", "+441234567890", time.Date(2014, 2, 1, 15, 7, 43, 0, time.UTC), "Ola", false},
+		Message{2, "REC UNREAD", "+441234567890", time.Date(2014, 2, 1, 15, 7, 43, 0, time.UTC), "Ja", true},
+	}
+	if len(*msg) != len(expected) {
+		t.Errorf("Expected: %#v, got %#v", expected, msg)
+	}
+	for i, m := range *msg {
+		if m != expected[i] {
+			t.Errorf("Expected: %#v, got %#v", expected, msg)
+		}
+	}
+	modem.Close()
+}
+
+var listMessagesEmptyReplay = []string{
+	"->AT+CMGL=\"ALL\"\r\n",
+	"<-\r\nOK\r\n",
+}
+
+func TestListMessagesEmpty(t *testing.T) {
+	OpenPort = func(config *serial.Config) (io.ReadWriteCloser, error) {
+		replay := appendLists(initReplay, listMessagesEmptyReplay)
+		return NewMockSerialPort(replay), nil
+	}
+	modem, err := Open(&serial.Config{}, true)
+	if err != nil {
+		t.Error("Expected: no error, got:", err)
+	}
+
+	msg, err := modem.ListMessages("ALL")
+	log.Println("ERROR", err)
+	expected := MessageList{}
+	if len(*msg) != len(expected) {
+		t.Errorf("Expected: %#v, got %#v", expected, msg)
+	}
+	modem.Close()
+}
+
+var storageAreasReplay = []string{
+	"->AT+CPMS=?\r\n",
+	"<-\r\n+CPMS: (\"ME\",\"MT\",\"SM\",\"SR\"),(\"ME\",\"MT\",\"SM\",\"SR\"),(\"ME\",\"MT\",\"SM\",\"SR\")\r\n\r\nOK\r\n",
+}
+
+func TestSupportedStorageAreas(t *testing.T) {
+	OpenPort = func(config *serial.Config) (io.ReadWriteCloser, error) {
+		replay := appendLists(initReplay, storageAreasReplay)
+		return NewMockSerialPort(replay), nil
+	}
+	modem, err := Open(&serial.Config{}, true)
+	if err != nil {
+		t.Error("Expected: no error, got:", err)
+	}
+
+	msg, _ := modem.SupportedStorageAreas()
+	expected := StorageAreas{
+		[]string{"ME", "MT", "SM", "SR"},
+		[]string{"ME", "MT", "SM", "SR"},
+		[]string{"ME", "MT", "SM", "SR"},
+	}
+	if fmt.Sprint(*msg) != fmt.Sprint(expected) {
+		t.Errorf("Expected: %#v, got %#v", expected, msg)
+	}
+	modem.Close()
+}

packets.go

@@ -27,12 +27,29 @@ type SMSCAddress struct {
 
 // +CMGR
 type Message struct {
+	Index     int
 	Status    string
 	Telephone string
 	Timestamp time.Time
 	Body      string
+	Last      bool
 }
 
+// +CPMS=?
+type StorageAreas struct {
+	Received []string
+	Sent     []string
+	New      []string
+}
+
+// +CPMS=...
+type StorageInfo struct {
+	UsedSpace1, MaxSpace1, UsedSpace2, MaxSpace2, UsedSpace3, MaxSpace3 int
+}
+
+// +CMGL
+type MessageList []Message
+
 // Simple OK response
 type OK struct{}
 

util.go

@@ -25,11 +25,12 @@ func parseTime(t string) time.Time {
 func quote(s interface{}) string {
 	switch v := s.(type) {
 	case string:
+		if v == "?" {
+			return v
+		}
 		return fmt.Sprintf(`"%s"`, v)
-	case int:
-		return fmt.Sprintf("%d", v)
-	case int64:
-		return fmt.Sprintf("%d", v)
+	case int, int64:
+		return fmt.Sprint(v)
 	default:
 		panic(fmt.Sprintf("Unsupported argument type: %T", v))
 	}
@@ -74,6 +75,16 @@ func unquotes(s string) []interface{} {
 	return args
 }
 
+// Unquote a parameter list of strings
+func stringsUnquotes(s string) []string {
+	args := unquotes(s)
+	var res []string
+	for _, arg := range args {
+		res = append(res, fmt.Sprint(arg))
+	}
+	return res
+}
+
 // A logging ReadWriteCloser for debugging
 type LogReadWriteCloser struct {
 	f io.ReadWriteCloser